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

#include "vehicle_gui.h"

    17

    18

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

    19

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

    20

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

    21

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

    22

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

    23

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

    24

static void CrashAirplane(Vehicle *v);

    25

    26

static void AircraftNextAirportPos_and_Order(Vehicle *v);

    27

static byte GetAircraftFlyingAltitude(const Vehicle *v);

    28

    29

static const SpriteID _aircraft_sprite[] = {

    30

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

    31

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

    32

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

    33

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

    34

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

    35

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

    36

	0x0EBD, 0x0EC5

    37

};

    38

    39

/* Find the nearest hangar to v

    40

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

    41

 * airports (like helipads only)

    42

 */

    43

static uint16 FindNearestHangar(const Vehicle *v)

    44

{

    45

	const Station *st;

    46

	uint best = 0;

    47

	uint16 index = INVALID_STATION;

    48

    49

	FOR_ALL_STATIONS(st) {

    50

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

    51

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

    52

			uint distance;

    53

    54

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

    55

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

    56

					!_cheats.no_jetcrash.value)

    57

				continue;

    58

    59

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

    60

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

    61

				best = distance;

    62

				index = st->index;

    63

			}

    64

		}

    65

	}

    66

	return index;

    67

}

    68

    69

#if 0

    70

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

    71

static bool HaveHangarInOrderList(Vehicle *v)

    72

{

    73

	const Order *order;

    74

    75

	FOR_VEHICLE_ORDERS(v, order) {

    76

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

    77

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

    78

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

    79

			// it surely doesn't have any hangars

    80

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

    81

				return true;

    82

		}

    83

	}

    84

    85

	return false;

    86

}

    87

#endif

    88

    89

int GetAircraftImage(Vehicle *v, byte direction)

    90

{

    91

	int spritenum = v->spritenum;

    92

    93

	if (is_custom_sprite(spritenum)) {

    94

		int sprite = GetCustomVehicleSprite(v, direction);

    95

    96

		if (sprite) return sprite;

    97

		spritenum = _engine_original_sprites[v->engine_type];

    98

	}

    99

	return direction + _aircraft_sprite[spritenum];

   100

}

   101

   102

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

   103

{

   104

	int spritenum = AircraftVehInfo(engine)->image_index;

   105

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

   106

   107

	if (is_custom_sprite(spritenum)) {

   108

		sprite = GetCustomVehicleIcon(engine, 6);

   109

		if (!sprite)

   110

			sprite = _engine_original_sprites[engine];

   111

	}

   112

   113

	DrawSprite(sprite | image_ormod, x, y);

   114

   115

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

   116

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

   117

	}

   118

}

   119

   120

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

   121

{

   122

	const AircraftVehicleInfo *avi = AircraftVehInfo(engine);

   123

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

   124

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

   125

	SetDParam(2, avi->passenger_capacity);

   126

	SetDParam(3, avi->mail_capacity);

   127

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

   128

   129

	DrawStringMultiCenter(x, y, STR_A02E_COST_MAX_SPEED_CAPACITY, maxw);

   130

}

   131

   132

/* Allocate many vehicles */

   133

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

   134

{

   135

	int i;

   136

	Vehicle *v;

   137

	bool success = true;

   138

   139

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

   140

		vl[i] = v = AllocateVehicle();

   141

		if (v == NULL) {

   142

			success = false;

   143

			break;

   144

		}

   145

		v->type = 1;

   146

	}

   147

   148

	while (--i >= 0) {

   149

		vl[i]->type = 0;

   150

	}

   151

   152

	return success;

   153

}

   154

   155

int32 EstimateAircraftCost(uint16 engine_type)

   156

{

   157

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

   158

}

   159

   160

   161

/* p1 = engine */

   162

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

   163

{

   164

	int32 value;

   165

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

   166

	UnitID unit_num;

   167

	TileIndex tile = TILE_FROM_XY(x,y);

   168

	const AircraftVehicleInfo *avi = AircraftVehInfo(p1);

   169

	Engine *e;

   170

   171

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

   172

   173

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

   174

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

   175

   176

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

   177

   178

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   179

   180

	value = EstimateAircraftCost(p1);

   181

   182

	if (flags & DC_QUERY_COST)

   183

		return value;

   184

   185

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

   186

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

   187

				IsOrderPoolFull())

   188

					return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   189

   190

	unit_num = GetFreeUnitNumber(VEH_Aircraft);

   191

	if (unit_num > _patches.max_aircraft)

   192

		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   193

   194

	if (flags & DC_EXEC) {

   195

		v = vl[0];

   196

		u = vl[1];

   197

   198

		v->unitnumber = unit_num;

   199

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

   200

		v->direction = 3;

   201

   202

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

   203

   204

		v->tile = tile;

   205

//		u->tile = 0;

   206

   207

		x = TileX(tile) * 16 + 5;

   208

		y = TileY(tile) * 16 + 3;

   209

   210

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

   211

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

   212

   213

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

   214

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

   215

   216

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

   217

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

   218

   219

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

   220

		v->z_height = 5;

   221

   222

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

   223

		u->z_height = 1;

   224

   225

		v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

   226

		u->vehstatus = VS_HIDDEN | VS_UNCLICKABLE | VS_DISASTER;

   227

   228

		v->spritenum = avi->image_index;

   229

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

   230

   231

		v->cargo_cap = avi->passenger_capacity;

   232

		u->cargo_cap = avi->mail_capacity;

   233

   234

		v->cargo_type = CT_PASSENGERS;

   235

		u->cargo_type = CT_MAIL;

   236

   237

		v->string_id = STR_SV_AIRCRAFT_NAME;

   238

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

   239

   240

//		v->load_unload_time_rem = 0;

   241

//		v->progress = 0;

   242

		v->last_station_visited = INVALID_STATION;

   243

//		v->destination_coords = 0;

   244

   245

		v->max_speed = avi->max_speed;

   246

		v->acceleration = avi->acceleration;

   247

		v->engine_type = (byte)p1;

   248

   249

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

   250

		v->value = value;

   251

   252

		u->subtype = 4;

   253

   254

		e = &_engines[p1];

   255

		v->reliability = e->reliability;

   256

		v->reliability_spd_dec = e->reliability_spd_dec;

   257

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

   258

   259

		_new_aircraft_id = v->index;

   260

   261

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

   262

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

   263

		// On hold for NewAI

   264

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

   265

   266

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

   267

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

   268

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

   269

		*/

   270

		{

   271

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

   272

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

   273

			uint i;

   274

   275

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

   276

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

   277

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

   278

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

   279

					break;

   280

				}

   281

			}

   282

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

   283

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

   284

		}

   285

   286

		v->u.air.state = HANGAR;

   287

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

   288

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

   289

		v->next = u;

   290

   291

		v->service_interval = _patches.servint_aircraft;

   292

   293

		v->date_of_last_service = _date;

   294

		v->build_year = _cur_year;

   295

   296

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

   297

   298

		VehiclePositionChanged(v);

   299

		VehiclePositionChanged(u);

   300

   301

		// Aircraft with 3 vehicles?

   302

		if (v->subtype == 0) {

   303

			w = vl[2];

   304

   305

			u->next = w;

   306

   307

			w->type = VEH_Aircraft;

   308

			w->direction = 0;

   309

			w->owner = _current_player;

   310

			w->x_pos = v->x_pos;

   311

			w->y_pos = v->y_pos;

   312

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

   313

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

   314

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

   315

			w->z_height = 1;

   316

			w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE;

   317

			w->subtype = 6;

   318

			w->cur_image = 0xF3D;

   319

			VehiclePositionChanged(w);

   320

		}

   321

   322

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   323

		RebuildVehicleLists();

   324

		InvalidateWindow(WC_COMPANY, v->owner);

   325

	}

   326

   327

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

   328

   329

	return value;

   330

}

   331

   332

bool IsAircraftHangarTile(TileIndex tile)

   333

{

   334

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

   335

	// 0x20 - hangar large airport (32)

   336

	// 0x41 - hangar small airport (65)

   337

	return IsTileType(tile, MP_STATION) &&

   338

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

   339

}

   340

   341

static bool CheckStoppedInHangar(Vehicle *v)

   342

{

   343

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

   344

		_error_message = STR_A01B_AIRCRAFT_MUST_BE_STOPPED;

   345

		return false;

   346

	}

   347

   348

	return true;

   349

}

   350

   351

   352

static void DoDeleteAircraft(Vehicle *v)

   353

{

   354

	DeleteWindowById(WC_VEHICLE_VIEW, v->index);

   355

	RebuildVehicleLists();

   356

	InvalidateWindow(WC_COMPANY, v->owner);

   357

	DeleteVehicleChain(v);

   358

	InvalidateWindowClasses(WC_AIRCRAFT_LIST);

   359

}

   360

   366

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

   367

{

   368

	Vehicle *v;

   369

   370

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   371

   372

	v = GetVehicle(p1);

   373

   374

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

   375

		return CMD_ERROR;

   376

   377

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   378

   379

	if (flags & DC_EXEC) {

   380

		// Invalidate depot

   381

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   382

		DoDeleteAircraft(v);

   383

	}

   384

   385

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

   386

   387

	return -(int32)v->value;

   388

}

   389

   395

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

   396

{

   397

	Vehicle *v;

   398

   399

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   400

   401

	v = GetVehicle(p1);

   402

   404

   405

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

   407

		return_cmd_error(STR_A017_AIRCRAFT_IS_IN_FLIGHT);

   408

   409

	if (flags & DC_EXEC) {

   410

		v->vehstatus ^= VS_STOPPED;

   411

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

   412

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   413

		InvalidateWindowClasses(WC_AIRCRAFT_LIST);

   414

	}

   415

   416

	return 0;

   417

}

   418

   419

// p1 = vehicle

   420

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

   421

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

   422

{

   423

	Vehicle *v;

   424

	Station *st;

   425

	uint16 next_airport_index;

   426

   427

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   428

   429

	v = GetVehicle(p1);

   430

   431

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

   432

		return CMD_ERROR;

   433

   434

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

   435

		if (flags & DC_EXEC) {

   436

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

   437

			v->current_order.type = OT_DUMMY;

   438

			v->current_order.flags = 0;

   439

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

   440

		}

   441

	} else {

   442

		bool next_airport_has_hangar = true;

   443

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

   444

		st = GetStation(next_airport_index);

   445

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

   446

		// it surely doesn't have any hangars

   447

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

   448

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

   449

			if (p2 == 0) {

   450

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

   451

				uint16 station = FindNearestHangar(v);

   452

   453

				next_airport_has_hangar = false;

   454

				if (station == INVALID_STATION) return CMD_ERROR;

   455

				st = GetStation(station);

   456

				next_airport_index = station;

   457

			} else {

   458

				return CMD_ERROR;

   459

			}

   460

		}

   461

   462

		if (flags & DC_EXEC) {

   463

			v->current_order.type = OT_GOTO_DEPOT;

   464

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

   465

			v->current_order.station = next_airport_index;

   466

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

   467

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

   468

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

   469

				AircraftNextAirportPos_and_Order(v);

   470

				v->u.air.targetairport = next_airport_index;

   471

			}

   472

		}

   473

	}

   474

   475

	return 0;

   476

}

   477

   478

// p1 = vehicle

   479

// p2 = new service int

   480

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

   481

{

   482

	Vehicle *v;

   483

   484

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   485

   486

	v = GetVehicle(p1);

   487

   488

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

   489

		return CMD_ERROR;

   490

   491

	if (flags & DC_EXEC) {

   492

		v->service_interval = (uint16)p2;

   493

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

   494

	}

   495

   496

	return 0;

   497

}

   498

   499

// p1 = vehicle

   500

// p2 = new cargo type(0xFF)

   501

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

   502

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

   503

{

   504

	Vehicle *v,*u;

   505

	int pass, mail;

   506

	int32 cost;