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

   361

// p1 = vehicle

   362

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

   363

{

   364

	Vehicle *v;

   365

   366

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   367

   368

	v = GetVehicle(p1);

   369

   370

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

   371

		return CMD_ERROR;

   372

   373

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   374

   375

	if (flags & DC_EXEC) {

   376

		// Invalidate depot

   377

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   378

		DoDeleteAircraft(v);

   379

	}

   380

   381

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

   382

   383

	return -(int32)v->value;

   384

}

   385

   386

// p1 = vehicle

   387

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

   388

{

   389

	Vehicle *v;

   390

   391

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   392

   393

	v = GetVehicle(p1);

   394

   395

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

   396

		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

   403

	if (flags & DC_EXEC) {

   404

		v->vehstatus ^= VS_STOPPED;

   405

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

   406

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   407

		InvalidateWindowClasses(WC_AIRCRAFT_LIST);

   408

	}

   409

   410

	return 0;

   411

}

   412

   413

// p1 = vehicle

   414

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

   415

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

   416

{

   417

	Vehicle *v;

   418

	Station *st;

   419

	uint16 next_airport_index;

   420

   421

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   422

   423

	v = GetVehicle(p1);

   424

   425

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

   426

		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

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

   438

		st = GetStation(next_airport_index);

   439

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

   440

		// it surely doesn't have any hangars

   441

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

   442

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

   443

			if (p2 == 0) {

   444

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

   445

				uint16 station = FindNearestHangar(v);

   446

   447

				next_airport_has_hangar = false;

   448

				if (station == INVALID_STATION) return CMD_ERROR;

   449

				st = GetStation(station);

   450

				next_airport_index = station;

   451

			} else {

   452

				return CMD_ERROR;

   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

// p1 = vehicle

   473

// p2 = new service int

   474

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

   475

{

   476

	Vehicle *v;

   477

   478

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   479

   480

	v = GetVehicle(p1);

   481

   482

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

   483

		return CMD_ERROR;

   484

   485

	if (flags & DC_EXEC) {

   486

		v->service_interval = (uint16)p2;

   487

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

   488

	}

   489

   490

	return 0;

   491

}

   492

   493

// p1 = vehicle

   494

// p2 = new cargo type(0xFF)

   495

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

   496

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

   497

{

   498

	Vehicle *v,*u;

   499

	int pass, mail;

   500

	int32 cost;

   501

	byte SkipStoppedInHangerCheck = (p2 & 0x100) >> 8; //excludes the cargo value

   502

	byte new_cargo_type = p2 & 0xFF; //gets the cargo number

   503

	AircraftVehicleInfo *avi;

   504

   505

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   506

   507

	v = GetVehicle(p1);