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

/* Find the nearest hangar to v

    39

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

    40

 * airports (like helipads only)

    41

 */

    42

static uint16 FindNearestHangar(const Vehicle *v)

    43

{

    44

	const Station *st;

    45

	uint best = 0;

    46

	uint16 index = INVALID_STATION;

    47

    48

	FOR_ALL_STATIONS(st) {

    49

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

    50

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

    51

			uint distance;

    52

    53

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

    54

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

    55

					!_cheats.no_jetcrash.value)

    56

				continue;

    57

    58

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

    59

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

    60

				best = distance;

    61

				index = st->index;

    62

			}

    63

		}

    64

	}

    65

	return index;

    66

}

    67

    69

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

    70

static bool HaveHangarInOrderList(Vehicle *v)

    71

{

    72

	const Order *order;

    73

    74

	FOR_VEHICLE_ORDERS(v, order) {

    75

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

    76

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

    77

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

    78

			// it surely doesn't have any hangars

    79

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

    80

				return true;

    81

		}

    82

	}

    83

    84

	return false;

    85

}

    87

    88

int GetAircraftImage(Vehicle *v, byte direction)

    89

{

    90

	int spritenum = v->spritenum;

    91

    92

	if (is_custom_sprite(spritenum)) {

    93

		int sprite = GetCustomVehicleSprite(v, direction);

    94

    95

		if (sprite) return sprite;

    96

		spritenum = _engine_original_sprites[v->engine_type];

    97

	}

    98

	return direction + _aircraft_sprite[spritenum];

    99

}

   100

   101

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

   102

{

   103

	int spritenum = AircraftVehInfo(engine)->image_index;

   104

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

   105

   106

	if (is_custom_sprite(spritenum)) {

   107

		sprite = GetCustomVehicleIcon(engine, 6);

   108

		if (!sprite)

   109

			sprite = _engine_original_sprites[engine];

   110

	}

   111

   112

	DrawSprite(sprite | image_ormod, x, y);

   113

   114

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

   115

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

   116

	}

   117

}

   118

   119

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

   120

{

   121

	const AircraftVehicleInfo *avi = AircraftVehInfo(engine);

   122

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

   123

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

   124

	SetDParam(2, avi->passenger_capacity);

   125

	SetDParam(3, avi->mail_capacity);

   126

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

   127

   128

	DrawStringMultiCenter(x, y, STR_A02E_COST_MAX_SPEED_CAPACITY, maxw);

   129

}

   130

   131

/* Allocate many vehicles */

   132

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

   133

{

   134

	int i;

   135

	Vehicle *v;

   136

	bool success = true;

   137

   138

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

   139

		vl[i] = v = AllocateVehicle();

   140

		if (v == NULL) {

   141

			success = false;

   142

			break;

   143

		}

   144

		v->type = 1;

   145

	}

   146

   147

	while (--i >= 0) {

   148

		vl[i]->type = 0;

   149

	}

   150

   151

	return success;

   152

}

   153

   154

int32 EstimateAircraftCost(uint16 engine_type)

   155

{

   156

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

   157

}

   158

   159

   160

/* p1 = engine */

   161

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

   162

{

   163

	int32 value;

   164

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

   165

	UnitID unit_num;

   166

	TileIndex tile = TILE_FROM_XY(x,y);

   167

	const AircraftVehicleInfo *avi = AircraftVehInfo(p1);

   168

	Engine *e;

   169

   170

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

   171

   172

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

   173

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

   174

   175

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

   176

   177

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   178

   179

	value = EstimateAircraftCost(p1);

   180

   181

	if (flags & DC_QUERY_COST)

   182

		return value;

   183

   184

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

   185

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

   186

				IsOrderPoolFull())

   187

					return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   188

   189

	unit_num = GetFreeUnitNumber(VEH_Aircraft);

   190

	if (unit_num > _patches.max_aircraft)

   191

		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   192

   193

	if (flags & DC_EXEC) {

   194

		v = vl[0];

   195

		u = vl[1];

   196

   197

		v->unitnumber = unit_num;

   198

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

   199

		v->direction = 3;

   200

   201

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

   202

   203

		v->tile = tile;

   204

//		u->tile = 0;

   205

   206

		x = TileX(tile) * 16 + 5;

   207

		y = TileY(tile) * 16 + 3;

   208

   209

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

   210

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

   211

   212

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

   213

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

   214

   215

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

   216

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

   217

   218

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

   219

		v->z_height = 5;

   220

   221

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

   222

		u->z_height = 1;

   223

   224

		v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

   225

		u->vehstatus = VS_HIDDEN | VS_UNCLICKABLE | VS_DISASTER;

   226

   227

		v->spritenum = avi->image_index;

   228

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

   229

   230

		v->cargo_cap = avi->passenger_capacity;

   231

		u->cargo_cap = avi->mail_capacity;

   232

   233

		v->cargo_type = CT_PASSENGERS;

   234

		u->cargo_type = CT_MAIL;

   235

   236

		v->string_id = STR_SV_AIRCRAFT_NAME;

   237

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

   238

   239

//		v->load_unload_time_rem = 0;

   240

//		v->progress = 0;

   241

		v->last_station_visited = INVALID_STATION;

   242

//		v->destination_coords = 0;

   243

   244

		v->max_speed = avi->max_speed;

   245

		v->acceleration = avi->acceleration;

   246

		v->engine_type = (byte)p1;

   247

   248

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

   249

		v->value = value;

   250

   251

		u->subtype = 4;

   252

   253

		e = &_engines[p1];

   254

		v->reliability = e->reliability;

   255

		v->reliability_spd_dec = e->reliability_spd_dec;

   256

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

   257

   258

		_new_aircraft_id = v->index;

   259

   260

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

   261

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

   262

		// On hold for NewAI

   263

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

   264

   265

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

   266

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

   267

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

   268

		*/

   269

		{

   270

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

   271

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

   272

			uint i;

   273

   274

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

   275

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

   276

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

   277

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

   278

					break;

   279

				}

   280

			}

   281

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

   282

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

   283

		}

   284

   285

		v->u.air.state = HANGAR;

   286

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

   287

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

   288

		v->next = u;

   289

   290

		v->service_interval = _patches.servint_aircraft;

   291

   292

		v->date_of_last_service = _date;

   293

		v->build_year = _cur_year;

   294

   295

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

   296

   297

		VehiclePositionChanged(v);

   298

		VehiclePositionChanged(u);

   299

   300

		// Aircraft with 3 vehicles?

   301

		if (v->subtype == 0) {

   302

			w = vl[2];

   303

   304

			u->next = w;

   305

   306

			w->type = VEH_Aircraft;

   307

			w->direction = 0;

   308

			w->owner = _current_player;

   309

			w->x_pos = v->x_pos;

   310

			w->y_pos = v->y_pos;

   311

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

   312

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

   313

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

   314

			w->z_height = 1;

   315

			w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE;

   316

			w->subtype = 6;

   317

			w->cur_image = 0xF3D;

   318

			VehiclePositionChanged(w);

   319

		}

   320

   321

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   322

		RebuildVehicleLists();

   323

		InvalidateWindow(WC_COMPANY, v->owner);

   324

	}

   325

   326

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

   327

   328

	return value;

   329

}

   330

   331

bool IsAircraftHangarTile(TileIndex tile)

   332

{

   333

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

   334

	// 0x20 - hangar large airport (32)

   335

	// 0x41 - hangar small airport (65)

   336

	return IsTileType(tile, MP_STATION) &&

   337

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

   338

}

   339

   340

static bool CheckStoppedInHangar(Vehicle *v)

   341

{

   342

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

   343

		_error_message = STR_A01B_AIRCRAFT_MUST_BE_STOPPED;

   344

		return false;

   345

	}

   346

   347

	return true;

   348

}

   349

   350

   351

static void DoDeleteAircraft(Vehicle *v)

   352

{

   353

	DeleteWindowById(WC_VEHICLE_VIEW, v->index);

   354

	RebuildVehicleLists();

   355

	InvalidateWindow(WC_COMPANY, v->owner);

   356

	DeleteVehicleChain(v);

   357

	InvalidateWindowClasses(WC_AIRCRAFT_LIST);

   358

}

   359

   360

// p1 = vehicle

   361

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

   362

{

   363

	Vehicle *v;

   364

   365

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   366

   367

	v = GetVehicle(p1);

   368

   369

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

   370

		return CMD_ERROR;

   371

   372

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   373

   374

	if (flags & DC_EXEC) {

   375

		// Invalidate depot

   376

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   377

		DoDeleteAircraft(v);

   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

// p1 = vehicle

   413

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

   414

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

   415

{

   416

	Vehicle *v;

   417

	Station *st;

   418

	uint16 next_airport_index;

   419

   420

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   421

   422

	v = GetVehicle(p1);

   423

   424

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

   425

		return CMD_ERROR;

   426

   427

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

   428

		if (flags & DC_EXEC) {

   429

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

   430

			v->current_order.type = OT_DUMMY;

   431

			v->current_order.flags = 0;

   432

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

   433

		}

   434

	} else {

   435

		bool next_airport_has_hangar = true;

   436

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

   437

		st = GetStation(next_airport_index);

   438

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

   439

		// it surely doesn't have any hangars

   440

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

   441

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

   442

			if (p2 == 0) {

   443

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

   444

				uint16 station = FindNearestHangar(v);

   445

   446

				next_airport_has_hangar = false;

   447

				if (station == INVALID_STATION) return CMD_ERROR;

   448

				st = GetStation(station);

   449

				next_airport_index = station;

   450

			} else {

   451

				return CMD_ERROR;

   452

			}

   453

		}

   454

   455

		if (flags & DC_EXEC) {

   456

			v->current_order.type = OT_GOTO_DEPOT;

   457

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

   458

			v->current_order.station = next_airport_index;

   459

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

   460

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

   461

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

   462

				AircraftNextAirportPos_and_Order(v);

   463

				v->u.air.targetairport = next_airport_index;

   464

			}

   465

		}

   466

	}

   467

   468

	return 0;

   469

}

   470

   471

// p1 = vehicle

   472

// p2 = new service int

   473

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

   474

{

   475

	Vehicle *v;

   476

   477

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   478

   479

	v = GetVehicle(p1);

   480

   481

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

   482

		return CMD_ERROR;

   483

   484

	if (flags & DC_EXEC) {

   485

		v->service_interval = (uint16)p2;

   486

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

   487

	}

   488

   489

	return 0;

   490

}

   491

   492

// p1 = vehicle

   493

// p2 = new cargo type(0xFF)

   494

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

   495

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

   496

{

   497

	Vehicle *v,*u;

   498

	int pass, mail;

   499

	int32 cost;

   500

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

   501

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

   502

	AircraftVehicleInfo *avi;

   503

   504

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   505

   506

	v = GetVehicle(p1);

   507