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 "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 = AircraftVehInfo(p1);

   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

   181

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

   182

   183

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   184

   185

	value = EstimateAircraftCost(p1);

   186

   187

	if (flags & DC_QUERY_COST) return value;

   188

   189

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

   190

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

   191

				IsOrderPoolFull())

   192

					return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   193

   194

	unit_num = GetFreeUnitNumber(VEH_Aircraft);

   195

	if (unit_num > _patches.max_aircraft)

   196

		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   197

   198

	if (flags & DC_EXEC) {

   199

		v = vl[0];

   200

		u = vl[1];

   201

   202

		v->unitnumber = unit_num;

   203

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

   204

		v->direction = 3;

   205

   206

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

   207

   208

		v->tile = tile;

   209

//		u->tile = 0;

   210

   211

		x = TileX(tile) * 16 + 5;

   212

		y = TileY(tile) * 16 + 3;

   213

   214

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

   215

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

   216

   217

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

   218

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

   219

   220

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

   221

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

   222

   223

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

   224

		v->z_height = 5;

   225

   226

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

   227

		u->z_height = 1;

   228

   229

		v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

   230

		u->vehstatus = VS_HIDDEN | VS_UNCLICKABLE | VS_DISASTER;

   231

   232

		v->spritenum = avi->image_index;

   233

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

   234

   235

		v->cargo_cap = avi->passenger_capacity;

   236

		u->cargo_cap = avi->mail_capacity;

   237

   238

		v->cargo_type = CT_PASSENGERS;

   239

		u->cargo_type = CT_MAIL;

   240

   241

		v->string_id = STR_SV_AIRCRAFT_NAME;

   242

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

   243

   244

//		v->load_unload_time_rem = 0;

   245

//		v->progress = 0;

   246

		v->last_station_visited = INVALID_STATION;

   247

//		v->destination_coords = 0;

   248

   249

		v->max_speed = avi->max_speed;

   250

		v->acceleration = avi->acceleration;

   251

		v->engine_type = (byte)p1;

   252

   253

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

   254

		v->value = value;

   255

   256

		u->subtype = 4;

   257

   258

		e = &_engines[p1];

   259

		v->reliability = e->reliability;

   260

		v->reliability_spd_dec = e->reliability_spd_dec;

   261

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

   262

   263

		_new_aircraft_id = v->index;

   264

   265

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

   266

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

   267

		// On hold for NewAI

   268

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

   269

   270

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

   271

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

   272

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

   273

		*/

   274

		{

   275

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

   276

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

   277

			uint i;

   278

   279

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

   280

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

   281

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

   282

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

   283

					break;

   284

				}

   285

			}

   286

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

   287

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

   288

		}

   289

   290

		v->u.air.state = HANGAR;

   291

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

   292

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

   293

		v->next = u;

   294

   295

		v->service_interval = _patches.servint_aircraft;

   296

   297

		v->date_of_last_service = _date;

   298

		v->build_year = _cur_year;

   299

   300

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

   301

   302

		VehiclePositionChanged(v);

   303

		VehiclePositionChanged(u);

   304

   305

		// Aircraft with 3 vehicles (chopper)?

   306

		if (v->subtype == 0) {

   307

			w = vl[2];

   308

   309

			u->next = w;

   310

   311

			w->type = VEH_Aircraft;

   312

			w->direction = 0;

   313

			w->owner = _current_player;

   314

			w->x_pos = v->x_pos;

   315

			w->y_pos = v->y_pos;

   316

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

   317

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

   318

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

   319

			w->z_height = 1;

   320

			w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE;

   321

			w->subtype = 6;

   322

			w->cur_image = 0xF3D;

   323

			VehiclePositionChanged(w);

   324

		}

   325

   326

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   327

		RebuildVehicleLists();

   328

		InvalidateWindow(WC_COMPANY, v->owner);

   329

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

   330

	}

   331

   332

	return value;

   333

}

   334

   335

bool IsAircraftHangarTile(TileIndex tile)

   336

{

   337

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

   338

	// 0x20 - hangar large airport (32)

   339

	// 0x41 - hangar small airport (65)

   340

	return IsTileType(tile, MP_STATION) &&

   341

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

   342

}

   343

   344

static bool CheckStoppedInHangar(Vehicle *v)

   345

{

   346

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

   347

		_error_message = STR_A01B_AIRCRAFT_MUST_BE_STOPPED;

   348

		return false;

   349

	}

   350

   351

	return true;

   352

}

   353

   354

   355

static void DoDeleteAircraft(Vehicle *v)

   356

{

   357

	DeleteWindowById(WC_VEHICLE_VIEW, v->index);

   358

	RebuildVehicleLists();

   359

	InvalidateWindow(WC_COMPANY, v->owner);

   360

	DeleteVehicleChain(v);

   361

	InvalidateWindowClasses(WC_AIRCRAFT_LIST);

   362

}

   363

   364

/** Sell an aircraft.

   365

 * @param x,y unused

   366

 * @param p1 vehicle ID to be sold

   367

 * @param p2 unused

   368

 */

   369

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

   370

{

   371

	Vehicle *v;

   372

   373

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   374

   375

	v = GetVehicle(p1);

   376

   377

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

   378

		return CMD_ERROR;

   379

   380

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   381

   382

	if (flags & DC_EXEC) {

   383

		// Invalidate depot

   384

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   385

		DoDeleteAircraft(v);

   386

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

   387

	}

   388

   389

	return -(int32)v->value;

   390

}

   391

   392

/** Start/Stop an aircraft.

   393

 * @param x,y unused

   394

 * @param p1 aircraft ID to start/stop

   395

 * @param p2 unused

   396

 */

   397

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

   398

{

   399

	Vehicle *v;

   400

   401

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   402

   403

	v = GetVehicle(p1);

   404

   405

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

   406

   407

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

   408

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

   409

		return_cmd_error(STR_A017_AIRCRAFT_IS_IN_FLIGHT);

   410

   411

	if (flags & DC_EXEC) {

   412

		v->vehstatus ^= VS_STOPPED;

   413

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

   414

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   415

		InvalidateWindowClasses(WC_AIRCRAFT_LIST);

   416

	}

   417

   418

	return 0;

   419

}

   420

   421

/** Send an aircraft to the hangar.

   422

 * @param x,y unused

   423

 * @param p1 vehicle ID to send to the hangar

   424

 * @param p2 various bitmasked elements

   425

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

   426

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

   427

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

   428

 */

   429

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

   430

{

   431

	Vehicle *v;

   432

   433

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   434

   435

	v = GetVehicle(p1);

   436

   437

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

   438

   439

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

   440

		if (flags & DC_EXEC) {

   441

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

   442

			v->current_order.type = OT_DUMMY;

   443

			v->current_order.flags = 0;

   444

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

   445

		}

   446

	} else {

   447

		bool next_airport_has_hangar = true;

   448

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

   449

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

   450

		const Station *st = GetStation(next_airport_index);

   451

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

   452

		// it surely doesn't have any hangars

   453

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

   454

			StationID station;

   455

   456

			if (p2 != 0) return CMD_ERROR;

   457

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

   458

			station = FindNearestHangar(v);

   459

   460

			next_airport_has_hangar = false;

   461

			if (station == INVALID_STATION) return CMD_ERROR;

   462

			st = GetStation(station);

   463

			next_airport_index = station;

   464

   465

		}

   466

   467

		if (flags & DC_EXEC) {

   468

			v->current_order.type = OT_GOTO_DEPOT;

   469

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

   470

			v->current_order.station = next_airport_index;

   471

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

   472

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

   473

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

   474

				AircraftNextAirportPos_and_Order(v);

   475

				v->u.air.targetairport = next_airport_index;

   476

			}

   477

		}

   478

	}

   479

   480

	return 0;

   481

}

   482

   483

/** Change the service interval for aircraft.

   484

 * @param x,y unused

   485

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

   486

 * @param p2 new service interval

   487

 */

   488

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

   489

{

   490

	Vehicle *v;

   491

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

   492

   493

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

   494

   495

	v = GetVehicle(p1);

   496

   497

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

   498

   499

	if (flags & DC_EXEC) {

   500

		v->service_interval = serv_int;

   501

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

   502

	}

   503

   504

	return 0;