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

/*  Send an aircraft to the hangar in the next station

   414

	p1 = index of the aircraft

   415

	p2 = bit 0..15 = index of station with hangar to use (only used if bit 17 is set)

   416

		 bit 16 = set v->set_for_replacement & do not stop in hangar

   417

		 bit 17 = goto the hangar in airport given in bit 0..15 instead of next stop

   418

		 bit 18 = clear v->set_for_replacement */

   419

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

   420

{

   421

	Vehicle *v;

   422

	Station *st;

   423

	uint16 next_airport_index;

   424

   425

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   426

   427

	v = GetVehicle(p1);

   428

   429

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

   430

		return CMD_ERROR;

   431

   432

	if (HASBIT(p2, 16)) v->set_for_replacement = true; //now all clients knows that the vehicle wants to be replaced

   433

   434

	if (HASBIT(p2, 18)) {

   435

		v->set_for_replacement = false;

   436

		return CMD_ERROR; // no need to send aircraft to a depot. We just told that it don't have to anymore

   437

	}

   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

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

   449

		st = GetStation(next_airport_index);

   450

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

   451

		// it surely doesn't have any hangars

   452

		if (st->xy == 0 || st->airport_tile == 0 || GetAirport(st->airport_type)->terminals == NULL) {

   453

			if (p2 == 0) {

   454

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

   455

				uint32 temp = FindNearestHangar(v);

   456

				next_airport_has_hangar = false;

   457

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

   458

				st = GetStation(temp);

   459

				next_airport_index = (uint16)temp;

   460

			} else {

   461

				return CMD_ERROR;

   462

			}

   463

		}

   464

   465

		if (flags & DC_EXEC) {

   466

			v->current_order.type = OT_GOTO_DEPOT;

   467

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

   468

			v->current_order.station = next_airport_index;

   469

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

   470

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

   471

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

   472

				AircraftNextAirportPos_and_Order(v);

   473

				v->u.air.targetairport = next_airport_index;

   474

			}

   475

		}

   476

	}

   477

   478

	return 0;

   479

}

   480

   481

// p1 = vehicle

   482

// p2 = new service int

   483

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

   484

{

   485

	Vehicle *v;

   486

   487

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   488

   489

	v = GetVehicle(p1);

   490

   491

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

   492

		return CMD_ERROR;

   493

   494

	if (flags & DC_EXEC) {

   495

		v->service_interval = (uint16)p2;

   496

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

   497

	}

   498

   499

	return 0;

   500

}

   501

   502

// p1 = vehicle

   503

// p2 = new cargo type(0xFF)

   504

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

   505

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

   506

{

   507

	Vehicle *v,*u;

   508

	int pass, mail;