1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     5

#include "vehicle.h"

     6

#include "engine.h"

     7

#include "command.h"

     8

#include "station.h"

     9

#include "news.h"

    10

#include "gfx.h"

    11

#include "sound.h"

    12

#include "player.h"

    13

#include "airport.h"

    14

    15

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

    16

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

    17

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

    18

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

    19

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

    20

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

    21

static void CrashAirplane(Vehicle *v);

    22

    23

static void AircraftNextAirportPos_and_Order(Vehicle *v);

    24

static byte GetAircraftFlyingAltitude(const Vehicle *v);

    25

    26

static const SpriteID _aircraft_sprite[] = {

    27

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

    28

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

    29

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

    30

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

    31

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

    32

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

    33

	0x0EBD, 0x0EC5

    34

};

    35

    36

int GetAircraftImage(Vehicle *v, byte direction)

    37

{

    38

	int spritenum = v->spritenum;

    39

    40

	if (is_custom_sprite(spritenum)) {

    41

		int sprite = GetCustomVehicleSprite(v, direction);

    42

    43

		if (sprite) return sprite;

    44

		spritenum = _engine_original_sprites[v->engine_type];

    45

	}

    46

	return direction + _aircraft_sprite[spritenum];

    47

}

    48

    49

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

    50

{

    51

	int spritenum = AircraftVehInfo(engine)->image_index;

    52

    53

	if (is_custom_sprite(spritenum)) {

    54

		int sprite = GetCustomVehicleIcon(engine, 6);

    55

    56

		if (sprite) {

    57

			DrawSprite(sprite | image_ormod, x, y);

    58

			return;

    59

		}

    60

		spritenum = _engine_original_sprites[engine];

    61

	}

    62

    63

	DrawSprite((6 + _aircraft_sprite[spritenum]) | image_ormod, x, y);

    64

    65

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

    66

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

    67

}

    68

    69

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

    70

{

    71

	const AircraftVehicleInfo *avi = AircraftVehInfo(engine);

    72

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

    73

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

    74

	SetDParam(2, avi->passenger_capacity);

    75

	SetDParam(3, avi->mail_capacity);

    76

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

    77

    78

	DrawStringMultiCenter(x, y, STR_A02E_COST_MAX_SPEED_CAPACITY, maxw);

    79

}

    80

    81

/* Allocate many vehicles */

    82

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

    83

{

    84

	int i;

    85

	Vehicle *v;

    86

	bool success = true;

    87

    88

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

    89

		vl[i] = v = AllocateVehicle();

    90

		if (v == NULL) {

    91

			success = false;

    92

			break;

    93

		}

    94

		v->type = 1;

    95

	}

    96

    97

	while (--i >= 0) {

    98

		vl[i]->type = 0;

    99

	}

   100

   101

	return success;

   102

}

   103

   104

int32 EstimateAircraftCost(uint16 engine_type)

   105

{

   106

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

   107

}

   108

   109

   110

/* p1 = engine */

   111

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

   112

{

   113

	int32 value;

   114

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

   115

	byte unit_num;

   116

	uint tile = TILE_FROM_XY(x,y);

   117

	const AircraftVehicleInfo *avi = AircraftVehInfo(p1);

   118

	Engine *e;

   119

   120

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   121

   122

	value = EstimateAircraftCost(p1);

   123

   124

	if (flags & DC_QUERY_COST)

   125

		return value;

   126

   127

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

   128

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

   129

				IsOrderPoolFull())

   130

					return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   131

   132

	unit_num = GetFreeUnitNumber(VEH_Aircraft);

   133

	if (unit_num > _patches.max_aircraft)

   134

		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   135

   136

	if (flags & DC_EXEC) {

   137

		v = vl[0];

   138

		u = vl[1];

   139

   140

		v->unitnumber = unit_num;

   141

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

   142

		v->direction = 3;

   143

   144

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

   145

   146

		v->tile = tile;

   147

//		u->tile = 0;

   148

   149

		x = TileX(tile) * 16 + 5;

   150

		y = TileY(tile) * 16 + 3;

   151

   152

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

   153

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

   154

   155

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

   156

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

   157

   158

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

   159

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

   160

   161

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

   162

		v->z_height = 5;

   163

   164

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

   165

		u->z_height = 1;

   166

   167

		v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

   168

		u->vehstatus = VS_HIDDEN | VS_UNCLICKABLE | VS_DISASTER;

   169

   170

		v->spritenum = avi->image_index;

   171

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

   172

   173

		v->cargo_cap = avi->passenger_capacity;

   174

		u->cargo_cap = avi->mail_capacity;

   175

   176

		v->cargo_type = CT_PASSENGERS;

   177

		u->cargo_type = CT_MAIL;

   178

   179

		v->string_id = STR_SV_AIRCRAFT_NAME;

   180

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

   181

   182

//		v->load_unload_time_rem = 0;

   183

//		v->progress = 0;

   184

		v->last_station_visited = 0xFFFF;

   185

//		v->destination_coords = 0;

   186

   187

		v->max_speed = avi->max_speed;

   188

		v->acceleration = avi->acceleration;

   189

		v->engine_type = (byte)p1;

   190

   191

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

   192

		v->value = value;

   193

   194

		u->subtype = 4;

   195

   196

		e = &_engines[p1];

   197

		v->reliability = e->reliability;

   198

		v->reliability_spd_dec = e->reliability_spd_dec;

   199

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

   200

   201

		_new_aircraft_id = v->index;

   202

   203

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

   204

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

   205

		// On hold for NewAI

   206

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

   207

   208

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

   209

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

   210

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

   211

		*/

   212

		{

   213

			Station *st;

   214

			const AirportFTAClass *Airport;

   215

			const TileIndexDiffC *cur_depot;

   216

			byte i = 0;

   217

			st = GetStation(_map2[tile]);

   218

			Airport = GetAirport(st->airport_type);

   219

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

   220

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

   221

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

   222

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

   223

					break;

   224

				}

   225

				i++;

   226

			}

   227

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

   228

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

   229

		}

   230

   231

		v->u.air.state = HANGAR;

   232

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

   233

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

   234

		v->next = u;

   235

   236

		v->service_interval = _patches.servint_aircraft;

   237

   238

		v->date_of_last_service = _date;

   239

		v->build_year = _cur_year;

   240

   241

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

   242

   243

		VehiclePositionChanged(v);

   244

		VehiclePositionChanged(u);

   245

   246

		// Aircraft with 3 vehicles?

   247

		if (v->subtype == 0) {

   248

			w = vl[2];

   249

   250

			u->next = w;

   251

   252

			w->type = VEH_Aircraft;

   253

			w->direction = 0;

   254

			w->owner = _current_player;

   255

			w->x_pos = v->x_pos;

   256

			w->y_pos = v->y_pos;

   257

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

   258

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

   259

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

   260

			w->z_height = 1;

   261

			w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE;

   262

			w->subtype = 6;

   263

			w->cur_image = 0xF3D;

   264

			VehiclePositionChanged(w);

   265

		}

   266

   267

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   268

		RebuildVehicleLists();

   269

		InvalidateWindow(WC_COMPANY, v->owner);

   270

	}

   271

   272

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

   273

   274

	return value;

   275

}

   276

   277

bool IsAircraftHangarTile(TileIndex tile)

   278

{

   279

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

   280

	// 0x20 - hangar large airport (32)

   281

	// 0x41 - hangar small airport (65)

   282

	return IsTileType(tile, MP_STATION) &&

   283

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

   284

}

   285

   286

static bool CheckStoppedInHangar(Vehicle *v)

   287

{

   288

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

   289

			!IsAircraftHangarTile(v->tile)) {

   290

		_error_message = STR_A01B_AIRCRAFT_MUST_BE_STOPPED;

   291

		return false;

   292

	}

   293

   294

	return true;

   295

}

   296

   297

   298

static void DoDeleteAircraft(Vehicle *v)

   299

{

   300

	DeleteWindowById(WC_VEHICLE_VIEW, v->index);

   301

	RebuildVehicleLists();

   302

	InvalidateWindow(WC_COMPANY, v->owner);

   303

	DeleteVehicleChain(v);

   304

	InvalidateWindowClasses(WC_AIRCRAFT_LIST);

   305

}

   306

   307

// p1 = vehicle

   308

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

   309

{

   310

	Vehicle *v;

   311

   312

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   313

   314

	v = GetVehicle(p1);

   315

   316

	if (!CheckOwnership(v->owner) || !CheckStoppedInHangar(v))

   317

		return CMD_ERROR;

   318

   319

	if (flags & DC_EXEC) {

   320

		// Invalidate depot

   321

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   322

   323

		DoDeleteAircraft(v);

   324

   325

	}

   326

   327

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

   328

   329

	return -(int32)v->value;

   330

}

   331

   332

// p1 = vehicle

   333

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

   334

{

   335

	Vehicle *v;

   336

   337

	v = GetVehicle(p1);

   338

   339

	if (!CheckOwnership(v->owner))

   340

		return CMD_ERROR;

   341

   342

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

   343

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

   344

		return_cmd_error(STR_A017_AIRCRAFT_IS_IN_FLIGHT);

   345

	}

   346

   347

	if (flags & DC_EXEC) {

   348

		v->vehstatus ^= VS_STOPPED;

   349

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

   350

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   351

		InvalidateWindowClasses(WC_AIRCRAFT_LIST);

   352

	}

   353

   354

	return 0;

   355

}

   356

   357

// p1 = vehicle

   358

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

   359

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

   360

{

   361

	Vehicle *v;

   362

	Station *st;

   363

   364

	v = GetVehicle(p1);

   365

   366

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

   367

   368

	if (!CheckOwnership(v->owner))

   369

		return CMD_ERROR;

   370

   371

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

   372

		if (flags & DC_EXEC) {

   373

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

   374

			v->current_order.type = OT_DUMMY;

   375

			v->current_order.flags = 0;

   376

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

   377

		}

   378

	} else {

   379

		st = GetStation(v->u.air.targetairport);

   380

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

   381

		// it surely doesn't have any hangars

   382

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

   383

					return CMD_ERROR;

   384

   385

		if (flags & DC_EXEC) {

   386

			v->current_order.type = OT_GOTO_DEPOT;

   387

			v->current_order.flags = p2 == 0 ? OF_NON_STOP | OF_FULL_LOAD : 0;

   388

			v->current_order.station = v->u.air.targetairport;

   389

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

   390

		}

   391

	}

   392

   393

	return 0;

   394

}

   395

   396

// p1 = vehicle

   397

// p2 = new service int

   398

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

   399

{

   400

	Vehicle *v;

   401

   402

	v = GetVehicle(p1);

   403

   404

	if (!CheckOwnership(v->owner))

   405

		return CMD_ERROR;

   406

   407

	if (flags & DC_EXEC) {

   408

		v->service_interval = (uint16)p2;

   409

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

   410

	}

   411

   412

	return 0;

   413

}

   414

   415

// p1 = vehicle

   416

// p2 = new cargo type(0xFF)

   417

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

   418

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

   419

{

   420

	Vehicle *v,*u;

   421

	int pass, mail;

   422

	int32 cost;

   423

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

   424

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

   425

	AircraftVehicleInfo *avi;

   426

   427

	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN);

   428

   429

	v = GetVehicle(p1);

   430

	avi = AircraftVehInfo(v->engine_type);

   431

	if (!CheckOwnership(v->owner) || (!CheckStoppedInHangar(v) && !(SkipStoppedInHangerCheck)))

   432

		return CMD_ERROR;

   433

   434

	switch (new_cargo_type) {

   435

		case CT_PASSENGERS:

   436

			pass = avi->passenger_capacity;

   437

			break;

   438

		case CT_MAIL:

   439

			pass = avi->passenger_capacity + avi->mail_capacity;

   440

			break;

   441

		case CT_GOODS:

   442

			pass = avi->passenger_capacity + avi->mail_capacity;

   443

			pass /= 2;

   444

			break;

   445

		default:

   446

			pass = avi->passenger_capacity + avi->mail_capacity;

   447

			pass /= 4;

   448

			break;

   449

	}

   450

	_aircraft_refit_capacity = pass;

   451

   452

	cost = 0;

   453

	if (IS_HUMAN_PLAYER(v->owner) && new_cargo_type != v->cargo_type) {

   454

		cost = _price.aircraft_base >> 7;

   455

	}

   456

   457

	if (flags & DC_EXEC) {

   458

		v->cargo_cap = pass;

   459

   460

		u = v->next;

   461

		mail = avi->mail_capacity;

   462

		if (new_cargo_type != CT_PASSENGERS) {

   463

			mail = 0;

   464

		}

   465

		u->cargo_cap = mail;

   466

		//autorefitted planes wants to keep the cargo

   467

		//it will be checked if the cargo is valid in CmdReplaceVehicle

   468

		if (!(SkipStoppedInHangerCheck))

   469

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

   470

		v->cargo_type = new_cargo_type;

   471

		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);

   472

	}

   473

   474

	return cost;

   475

}

   476

   477

void HandleClickOnAircraft(Vehicle *v)

   478

{

   479

	ShowAircraftViewWindow(v);

   480

}

   481

   482

static void CheckIfAircraftNeedsService(Vehicle *v)

   483

{

   484

	Station *st;

   485

   486

	if (_patches.servint_aircraft == 0)

   487

		return;

   488

   489

	if (!VehicleNeedsService(v))

   490

		return;

   491

   492

	if (v->vehstatus & VS_STOPPED)

   493

		return;

   494

   495

	if (v->current_order.type == OT_GOTO_DEPOT &&

   496

			v->current_order.flags & OF_FULL_LOAD)

   497

		return;

   498

   499

	if (_patches.gotodepot && VehicleHasDepotOrders(v))

   500

 		return;

   501

   502

	st = GetStation(v->current_order.station);

   503

	// only goto depot if the target airport has terminals (eg. it is airport)

   504

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

   505

//		printf("targetairport = %d, st->index = %d\n", v->u.air.targetairport, st->index);

   506

//		v->u.air.targetairport = st->index;

   507

		v->current_order.type = OT_GOTO_DEPOT;

   508

		v->current_order.flags = OF_NON_STOP;

   509

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

   510

	} else if (v->current_order.type == OT_GOTO_DEPOT) {

   511

		v->current_order.type = OT_DUMMY;

   512

		v->current_order.flags = 0;

   513