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

    17

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

    18

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

    19

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

    20

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

    21

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

    22

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

    23

static void CrashAirplane(Vehicle *v);

    24

    25

static void AircraftNextAirportPos_and_Order(Vehicle *v);

    26

static byte GetAircraftFlyingAltitude(const Vehicle *v);

    27

    28

static const SpriteID _aircraft_sprite[] = {

    29

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

    30

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

    31

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

    32

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

    33

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

    34

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

    35

	0x0EBD, 0x0EC5

    36

};

    37

    38

// use this to find the nearest hangar to v

    39

// bit 16 is set in the return value if the player do not have any airports with a hangar (like helipads only)

    40

static uint32 FindNearestHangar(Vehicle *v)

    41

{

    42

	Station *st;

    43

	uint temp_distance, distance = 0xFFFF;

    44

	uint16 index_to_target = 0;

    45

    46

	FOR_ALL_STATIONS(st) {

    47

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

    48

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

    49

				// don't crash the planes if we know they can't land at the airport

    50

				if (HASBIT(v->subtype,1) && st->airport_type == AT_SMALL && !_cheats.no_jetcrash.value) continue;

    51

    52

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

    53

				if (temp_distance < distance) {

    54

					distance = temp_distance;

    55

					index_to_target = st->index;

    56

				}

    57

			}

    58

		}

    59

	}

    60

	if (distance == 65000)

    61

		SETBIT(index_to_target, 16);

    62

	return index_to_target;

    63

}

    64

    65

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

    66

static bool HaveHangarInOrderList(Vehicle *v)

    67

{

    68

	const Order *order;

    69

    70

	FOR_VEHICLE_ORDERS(v, order) {

    71

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

    72

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

    73

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

    74

			// it surely doesn't have any hangars

    75

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

    76

				return true;

    77

		}

    78

	}

    79

    80

	return false;

    81

}

    82

    83

int GetAircraftImage(Vehicle *v, byte direction)

    84

{

    85

	int spritenum = v->spritenum;

    86

    87

	if (is_custom_sprite(spritenum)) {

    88

		int sprite = GetCustomVehicleSprite(v, direction);

    89

    90

		if (sprite) return sprite;

    91

		spritenum = _engine_original_sprites[v->engine_type];

    92

	}

    93

	return direction + _aircraft_sprite[spritenum];

    94

}

    95

    96

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

    97

{

    98

	int spritenum = AircraftVehInfo(engine)->image_index;

    99

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

   100

   101

	if (is_custom_sprite(spritenum)) {

   102

		sprite = GetCustomVehicleIcon(engine, 6);

   103

		if (!sprite)

   104

			sprite = _engine_original_sprites[engine];

   105

	}

   106

   107

	DrawSprite(sprite | image_ormod, x, y);

   108

   109

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

   110

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

   111

	}

   112

}

   113

   114

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

   115

{

   116

	const AircraftVehicleInfo *avi = AircraftVehInfo(engine);

   117

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

   118

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

   119

	SetDParam(2, avi->passenger_capacity);

   120

	SetDParam(3, avi->mail_capacity);

   121

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

   122

   123

	DrawStringMultiCenter(x, y, STR_A02E_COST_MAX_SPEED_CAPACITY, maxw);

   124

}

   125

   126

/* Allocate many vehicles */

   127

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

   128

{

   129

	int i;

   130

	Vehicle *v;

   131

	bool success = true;

   132

   133

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

   134

		vl[i] = v = AllocateVehicle();

   135

		if (v == NULL) {

   136

			success = false;

   137

			break;

   138

		}

   139

		v->type = 1;

   140

	}

   141

   142

	while (--i >= 0) {

   143

		vl[i]->type = 0;

   144

	}

   145

   146

	return success;

   147

}

   148

   149

int32 EstimateAircraftCost(uint16 engine_type)

   150

{

   151

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

   152

}

   153

   154

   155

/* p1 = engine */

   156

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

   157

{

   158

	int32 value;

   159

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

   160

	UnitID unit_num;

   161

	uint tile = TILE_FROM_XY(x,y);

   162

	const AircraftVehicleInfo *avi = AircraftVehInfo(p1);

   163

	Engine *e;

   164

   165

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

   166

   167

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

   168

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

   169

   170

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

   171

   172

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   173

   174

	value = EstimateAircraftCost(p1);

   175

   176

	if (flags & DC_QUERY_COST)

   177

		return value;

   178

   179

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

   180

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

   181

				IsOrderPoolFull())

   182

					return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   183

   184

	unit_num = GetFreeUnitNumber(VEH_Aircraft);

   185

	if (unit_num > _patches.max_aircraft)

   186

		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   187

   188

	if (flags & DC_EXEC) {

   189

		v = vl[0];

   190

		u = vl[1];

   191

   192

		v->unitnumber = unit_num;

   193

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

   194

		v->direction = 3;

   195

   196

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

   197

   198

		v->tile = tile;

   199

//		u->tile = 0;

   200

   201

		x = TileX(tile) * 16 + 5;

   202

		y = TileY(tile) * 16 + 3;

   203

   204

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

   205

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

   206

   207

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

   208

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

   209

   210

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

   211

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

   212

   213

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

   214

		v->z_height = 5;

   215

   216

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

   217

		u->z_height = 1;

   218

   219

		v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

   220

		u->vehstatus = VS_HIDDEN | VS_UNCLICKABLE | VS_DISASTER;

   221

   222

		v->spritenum = avi->image_index;

   223

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

   224

   225

		v->cargo_cap = avi->passenger_capacity;

   226

		u->cargo_cap = avi->mail_capacity;

   227

   228

		v->cargo_type = CT_PASSENGERS;

   229

		u->cargo_type = CT_MAIL;

   230

   231

		v->string_id = STR_SV_AIRCRAFT_NAME;

   232

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

   233

   234

//		v->load_unload_time_rem = 0;

   235

//		v->progress = 0;

   236

		v->last_station_visited = INVALID_STATION;

   237

//		v->destination_coords = 0;

   238

   239

		v->max_speed = avi->max_speed;

   240

		v->acceleration = avi->acceleration;

   241

		v->engine_type = (byte)p1;

   242

   243

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

   244

		v->value = value;

   245

   246

		u->subtype = 4;

   247

   248

		e = &_engines[p1];

   249

		v->reliability = e->reliability;

   250

		v->reliability_spd_dec = e->reliability_spd_dec;

   251

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

   252

   253

		_new_aircraft_id = v->index;

   254

   255

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

   256

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

   257

		// On hold for NewAI

   258

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

   259

   260

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

   261

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

   262

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

   263

		*/

   264

		{

   265

			Station *st;

   266

			const AirportFTAClass *Airport;

   267

			const TileIndexDiffC *cur_depot;

   268

			byte i = 0;

   269

			st = GetStation(_map2[tile]);

   270

			Airport = GetAirport(st->airport_type);

   271

			for (cur_depot = Airport->airport_depots; i != Airport->nof_depots; cur_depot++) {

   272

				if ((uint)(st->airport_tile + ToTileIndexDiff(*cur_depot)) == tile) {

   273

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

   274

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

   275

					break;

   276

				}

   277

				i++;

   278

			}

   279

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

   280

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

   281

		}

   282

   283

		v->u.air.state = HANGAR;

   284

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

   285

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

   286

		v->next = u;

   287

   288

		v->service_interval = _patches.servint_aircraft;

   289

   290

		v->date_of_last_service = _date;

   291

		v->build_year = _cur_year;

   292

   293

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

   294

   295

		VehiclePositionChanged(v);

   296

		VehiclePositionChanged(u);

   297

   298

		// Aircraft with 3 vehicles?

   299

		if (v->subtype == 0) {

   300

			w = vl[2];

   301

   302

			u->next = w;

   303

   304

			w->type = VEH_Aircraft;

   305

			w->direction = 0;

   306

			w->owner = _current_player;

   307

			w->x_pos = v->x_pos;

   308

			w->y_pos = v->y_pos;

   309

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

   310

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

   311

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

   312

			w->z_height = 1;

   313

			w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE;

   314

			w->subtype = 6;

   315

			w->cur_image = 0xF3D;

   316

			VehiclePositionChanged(w);

   317

		}

   318

   319

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   320

		RebuildVehicleLists();

   321

		InvalidateWindow(WC_COMPANY, v->owner);

   322

	}

   323

   324

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

   325

   326

	return value;

   327

}

   328

   329

bool IsAircraftHangarTile(TileIndex tile)

   330

{

   331

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

   332

	// 0x20 - hangar large airport (32)

   333

	// 0x41 - hangar small airport (65)

   334

	return IsTileType(tile, MP_STATION) &&

   335

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

   336

}

   337

   338

static bool CheckStoppedInHangar(Vehicle *v)

   339

{

   340

	if (!(v->vehstatus&VS_STOPPED) ||

   341

			!IsAircraftHangarTile(v->tile)) {

   342

		_error_message = STR_A01B_AIRCRAFT_MUST_BE_STOPPED;

   343

		return false;

   344

	}

   345

   346

	return true;

   347

}

   348

   349

   350

static void DoDeleteAircraft(Vehicle *v)

   351

{

   352

	DeleteWindowById(WC_VEHICLE_VIEW, v->index);

   353

	RebuildVehicleLists();

   354

	InvalidateWindow(WC_COMPANY, v->owner);

   355

	DeleteVehicleChain(v);

   356

	InvalidateWindowClasses(WC_AIRCRAFT_LIST);

   357

}

   358

   359

// p1 = vehicle

   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

   377

		DoDeleteAircraft(v);

   378

   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 || GetAirport(st->airport_type)->terminals == NULL) {

   442

			if (p2 == 0) {

   443

				// the aircraft have to search for a hangar on it's own

   444

				uint32 temp = FindNearestHangar(v);

   445

				next_airport_has_hangar = false;

   446

				if (HASBIT(temp, 16)) return CMD_ERROR; // the player does not own a hangar

   447

				st = GetStation(temp);

   448

				next_airport_index = (uint16)temp;

   449

			} else {

   450

				return CMD_ERROR;

   451

			}

   452

		}

   453

   454

		if (flags & DC_EXEC) {

   455

			v->current_order.type = OT_GOTO_DEPOT;

   456

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

   457

			v->current_order.station = next_airport_index;

   458

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

   459

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

   460

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

   461

				AircraftNextAirportPos_and_Order(v);

   462

				v->u.air.targetairport = next_airport_index;

   463

			}

   464

		}

   465

	}

   466

   467

	return 0;

   468

}

   469

   470

// p1 = vehicle

   471

// p2 = new service int

   472

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

   473

{

   474

	Vehicle *v;

   475

   476

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   477

   478

	v = GetVehicle(p1);

   479

   480

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

   481

		return CMD_ERROR;

   482

   483

	if (flags & DC_EXEC) {

   484

		v->service_interval = (uint16)p2;

   485

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

   486

	}

   487

   488

	return 0;

   489

}

   490

   491

// p1 = vehicle

   492

// p2 = new cargo type(0xFF)

   493

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

   494

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

   495

{

   496

	Vehicle *v,*u;

   497

	int pass, mail;

   498

	int32 cost;

   499

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

   500

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

   501

	AircraftVehicleInfo *avi;

   502

   503

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   504

   505

	v = GetVehicle(p1);

   506

   507

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

   508