1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     5

#include "tile.h"

     6

#include "vehicle.h"

     7

#include "engine.h"

     8

#include "command.h"

     9

#include "station.h"

    10

#include "news.h"

    11

#include "gfx.h"

    12

#include "sound.h"

    13

#include "player.h"

    14

#include "airport.h"

    15

    16

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

    17

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

    18

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

    19

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

    20

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

    21

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

    22

static void CrashAirplane(Vehicle *v);

    23

    24

static void AircraftNextAirportPos_and_Order(Vehicle *v);

    25

static byte GetAircraftFlyingAltitude(const Vehicle *v);

    26

    27

static const SpriteID _aircraft_sprite[] = {

    28

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

    29

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

    30

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

    31

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

    32

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

    33

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

    34

	0x0EBD, 0x0EC5

    35

};

    36

    37

// use this to find the nearest hangar to v

    38

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

    39

static uint32 FindNearestHangar(Vehicle *v)

    40

{

    41

	Station *st;

    42

	uint temp_distance, distance = 0xFFFF;

    43

	uint16 index_to_target = 0;

    44

    45

	FOR_ALL_STATIONS(st) {

    46

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

    47

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

    48

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

    49

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

    50

    51

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

    52

				if (temp_distance < distance) {

    53

					distance = temp_distance;

    54

					index_to_target = st->index;

    55

				}

    56

			}

    57

		}

    58

	}

    59

	if (distance == 65000)

    60

		SETBIT(index_to_target, 16);

    61

	return index_to_target;

    62

}

    63

    64

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

    65

static bool HaveHangarInOrderList(Vehicle *v)

    66

{

    67

	const Order *order;

    68

    69

	FOR_VEHICLE_ORDERS(v, order) {

    70

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

    71

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

    72

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

    73

			// it surely doesn't have any hangars

    74

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

    75

				return true;

    76

		}

    77

	}

    78

    79

	return false;

    80

}

    81

    82

int GetAircraftImage(Vehicle *v, byte direction)

    83

{

    84

	int spritenum = v->spritenum;

    85

    86

	if (is_custom_sprite(spritenum)) {

    87

		int sprite = GetCustomVehicleSprite(v, direction);

    88

    89

		if (sprite) return sprite;

    90

		spritenum = _engine_original_sprites[v->engine_type];

    91

	}

    92

	return direction + _aircraft_sprite[spritenum];

    93

}

    94

    95

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

    96

{

    97

	int spritenum = AircraftVehInfo(engine)->image_index;

    98

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

    99

   100

	if (is_custom_sprite(spritenum)) {

   101

		sprite = GetCustomVehicleIcon(engine, 6);

   102

		if (!sprite)

   103

			sprite = _engine_original_sprites[engine];

   104

	}

   105

   106

	DrawSprite(sprite | image_ormod, x, y);

   107

   108

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

   109

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

   110

	}

   111

}

   112

   113

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

   114

{

   115

	const AircraftVehicleInfo *avi = AircraftVehInfo(engine);

   116

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

   117

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

   118

	SetDParam(2, avi->passenger_capacity);

   119

	SetDParam(3, avi->mail_capacity);

   120

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

   121

   122

	DrawStringMultiCenter(x, y, STR_A02E_COST_MAX_SPEED_CAPACITY, maxw);

   123

}

   124

   125

/* Allocate many vehicles */

   126

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

   127

{

   128

	int i;

   129

	Vehicle *v;

   130

	bool success = true;

   131

   132

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

   133

		vl[i] = v = AllocateVehicle();

   134

		if (v == NULL) {

   135

			success = false;

   136

			break;

   137

		}

   138

		v->type = 1;

   139

	}

   140

   141

	while (--i >= 0) {

   142

		vl[i]->type = 0;

   143

	}

   144

   145

	return success;

   146

}

   147

   148

int32 EstimateAircraftCost(uint16 engine_type)

   149

{

   150

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

   151

}

   152

   153

   154

/* p1 = engine */

   155

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

   156

{

   157

	int32 value;

   158

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

   159

	byte unit_num;

   160

	uint tile = TILE_FROM_XY(x,y);

   161

	const AircraftVehicleInfo *avi = AircraftVehInfo(p1);

   162

	Engine *e;

   163

   164

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

   165

   166

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

   167

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

   168

   169

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

   170

   171

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   172

   173

	value = EstimateAircraftCost(p1);

   174

   175

	if (flags & DC_QUERY_COST)

   176

		return value;

   177

   178

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

   179

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

   180

				IsOrderPoolFull())

   181

					return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   182

   183

	unit_num = GetFreeUnitNumber(VEH_Aircraft);

   184

	if (unit_num > _patches.max_aircraft)

   185

		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   186

   187

	if (flags & DC_EXEC) {

   188

		v = vl[0];

   189

		u = vl[1];

   190

   191

		v->unitnumber = unit_num;

   192

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

   193

		v->direction = 3;

   194

   195

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

   196

   197

		v->tile = tile;

   198

//		u->tile = 0;

   199

   200

		x = TileX(tile) * 16 + 5;

   201

		y = TileY(tile) * 16 + 3;

   202

   203

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

   204

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

   205

   206

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

   207

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

   208

   209

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

   210

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

   211

   212

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

   213

		v->z_height = 5;

   214

   215

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

   216

		u->z_height = 1;

   217

   218

		v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

   219

		u->vehstatus = VS_HIDDEN | VS_UNCLICKABLE | VS_DISASTER;

   220

   221

		v->spritenum = avi->image_index;

   222

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

   223

   224

		v->cargo_cap = avi->passenger_capacity;

   225

		u->cargo_cap = avi->mail_capacity;

   226

   227

		v->cargo_type = CT_PASSENGERS;

   228

		u->cargo_type = CT_MAIL;

   229

   230

		v->string_id = STR_SV_AIRCRAFT_NAME;

   231

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

   232

   233

//		v->load_unload_time_rem = 0;

   234

//		v->progress = 0;

   235

		v->last_station_visited = 0xFFFF;

   236

//		v->destination_coords = 0;

   237

   238

		v->max_speed = avi->max_speed;

   239

		v->acceleration = avi->acceleration;

   240

		v->engine_type = (byte)p1;

   241

   242

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

   243

		v->value = value;

   244

   245

		u->subtype = 4;

   246

   247

		e = &_engines[p1];

   248

		v->reliability = e->reliability;

   249

		v->reliability_spd_dec = e->reliability_spd_dec;

   250

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

   251

   252

		_new_aircraft_id = v->index;

   253

   254

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

   255

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

   256

		// On hold for NewAI

   257

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

   258

   259

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

   260

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

   261

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

   262

		*/

   263

		{

   264

			Station *st;

   265

			const AirportFTAClass *Airport;

   266

			const TileIndexDiffC *cur_depot;

   267

			byte i = 0;

   268

			st = GetStation(_map2[tile]);

   269

			Airport = GetAirport(st->airport_type);

   270

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

   271

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

   272

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

   273

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

   274

					break;

   275

				}

   276

				i++;

   277

			}

   278

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

   279

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

   280

		}

   281

   282

		v->u.air.state = HANGAR;

   283

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

   284

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

   285

		v->next = u;

   286

   287

		v->service_interval = _patches.servint_aircraft;

   288

   289

		v->date_of_last_service = _date;

   290

		v->build_year = _cur_year;

   291

   292

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

   293

   294

		VehiclePositionChanged(v);

   295

		VehiclePositionChanged(u);

   296

   297

		// Aircraft with 3 vehicles?

   298

		if (v->subtype == 0) {

   299

			w = vl[2];

   300

   301

			u->next = w;

   302

   303

			w->type = VEH_Aircraft;

   304

			w->direction = 0;

   305

			w->owner = _current_player;

   306

			w->x_pos = v->x_pos;

   307

			w->y_pos = v->y_pos;

   308

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

   309

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

   310

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

   311

			w->z_height = 1;

   312

			w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE;

   313

			w->subtype = 6;

   314

			w->cur_image = 0xF3D;

   315

			VehiclePositionChanged(w);

   316

		}

   317

   318

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   319

		RebuildVehicleLists();

   320

		InvalidateWindow(WC_COMPANY, v->owner);

   321

	}

   322

   323

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

   324

   325

	return value;

   326

}

   327

   328

bool IsAircraftHangarTile(TileIndex tile)

   329

{

   330

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

   331

	// 0x20 - hangar large airport (32)

   332

	// 0x41 - hangar small airport (65)

   333

	return IsTileType(tile, MP_STATION) &&

   334

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

   335

}

   336

   337

static bool CheckStoppedInHangar(Vehicle *v)

   338

{

   339

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

   340

			!IsAircraftHangarTile(v->tile)) {

   341

		_error_message = STR_A01B_AIRCRAFT_MUST_BE_STOPPED;

   342

		return false;

   343

	}

   344

   345

	return true;

   346

}

   347

   348

   349

static void DoDeleteAircraft(Vehicle *v)

   350

{

   351

	DeleteWindowById(WC_VEHICLE_VIEW, v->index);

   352

	RebuildVehicleLists();

   353

	InvalidateWindow(WC_COMPANY, v->owner);

   354

	DeleteVehicleChain(v);

   355

	InvalidateWindowClasses(WC_AIRCRAFT_LIST);

   356

}

   357

   358

// p1 = vehicle

   359

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

   360

{

   361

	Vehicle *v;

   362

   363

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   364

   365

	v = GetVehicle(p1);

   366

   367

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

   368

		return CMD_ERROR;

   369

   370

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   371

   372

	if (flags & DC_EXEC) {

   373

		// Invalidate depot

   374

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   375

   376

		DoDeleteAircraft(v);

   377

   378

	}

   379

   380

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

   381

   382

	return -(int32)v->value;

   383

}

   384

   385

// p1 = vehicle

   386

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

   387

{

   388

	Vehicle *v;

   389

   390

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   391

   392

	v = GetVehicle(p1);

   393

   394

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

   395

		return CMD_ERROR;

   396

   397

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

   398

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

   399

		return_cmd_error(STR_A017_AIRCRAFT_IS_IN_FLIGHT);

   400

	}

   401

   402

	if (flags & DC_EXEC) {

   403

		v->vehstatus ^= VS_STOPPED;

   404

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

   405

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   406

		InvalidateWindowClasses(WC_AIRCRAFT_LIST);

   407

	}

   408

   409

	return 0;

   410

}

   411

   412

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

   413

	p1 = index of the aircraft

   414

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

   415

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

   416

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

   417

		 bit 18 = clear v->set_for_replacement */

   418

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

   419

{

   420

	Vehicle *v;

   421

	Station *st;

   422

	uint16 next_airport_index;

   423

   424

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   425

   426

	v = GetVehicle(p1);

   427

   428

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

   429

		return CMD_ERROR;

   430

   431

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

   432

   433

	if (HASBIT(p2, 18)) {

   434

		v->set_for_replacement = false;

   435

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

   436

	}

   437

   438

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

   439

		if (flags & DC_EXEC) {

   440

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

   441

			v->current_order.type = OT_DUMMY;

   442

			v->current_order.flags = 0;

   443

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

   444

		}

   445

	} else {

   446

		bool next_airport_has_hangar = true;

   447

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

   448

		st = GetStation(next_airport_index);

   449

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

   450

		// it surely doesn't have any hangars

   451

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

   452

			if (p2 == 0) {

   453

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

   455

				next_airport_has_hangar = false;

   457

				st = GetStation(temp);

   458

				next_airport_index = (uint16)temp;

   459

			} else {

   460

				return CMD_ERROR;

   461

			}

   462

		}

   463

   464

		if (flags & DC_EXEC) {

   465

			v->current_order.type = OT_GOTO_DEPOT;

   466

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

   467

			v->current_order.station = next_airport_index;

   468

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

   469

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

   470

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

   471

				AircraftNextAirportPos_and_Order(v);

   472

				v->u.air.targetairport = next_airport_index;

   473

			}

   474

		}

   475

	}

   476

   477

	return 0;

   478

}

   479

   480

// p1 = vehicle

   481

// p2 = new service int

   482

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

   483

{

   484

	Vehicle *v;

   485

   486

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   487

   488

	v = GetVehicle(p1);

   489

   490

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

   491

		return CMD_ERROR;

   492

   493

	if (flags & DC_EXEC) {

   494

		v->service_interval = (uint16)p2;

   495

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

   496

	}

   497

   498

	return 0;

   499

}

   500

   501

// p1 = vehicle

   502

// p2 = new cargo type(0xFF)

   503

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

   504

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

   505

{

   506

	Vehicle *v,*u;

   507

	int pass, mail;

   508

	int32 cost;