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

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

   359

{

   360

	Vehicle *v;

   361

	Station *st;

   362

   363

	v = GetVehicle(p1);

   364

   365

	if (!CheckOwnership(v->owner))

   366

		return CMD_ERROR;

   367

   368

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

   369

		if (flags & DC_EXEC) {

   370

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

   371

			v->current_order.type = OT_DUMMY;

   372

			v->current_order.flags = 0;

   373

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

   374

		}

   375

	} else {

   376

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

   377

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

   378

		// it surely doesn't have any hangars

   379

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

   380

					return CMD_ERROR;

   381

   382

		if (flags & DC_EXEC) {

   383

			v->current_order.type = OT_GOTO_DEPOT;

   384

			v->current_order.flags = OF_NON_STOP | OF_FULL_LOAD;

   385

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

   386

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

   387

		}

   388

	}

   389

   390

	return 0;

   391

}

   392

   393

// p1 = vehicle

   394

// p2 = new service int

   395

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

   396

{

   397

	Vehicle *v;

   398

   399

	v = GetVehicle(p1);

   400

   401

	if (!CheckOwnership(v->owner))

   402

		return CMD_ERROR;

   403

   404

	if (flags & DC_EXEC) {

   405

		v->service_interval = (uint16)p2;

   406

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

   407

	}

   408

   409

	return 0;

   410

}

   411

   412

// p1 = vehicle

   413

// p2 = new cargo type(0xFF)

   414

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

   415

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

   416

{

   417

	Vehicle *v,*u;

   418

	int pass, mail;

   419

	int32 cost;

   420

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

   421

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

   422

	AircraftVehicleInfo *avi;

   423

   424

	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN);

   425

   426

	v = GetVehicle(p1);

   427

	avi = AircraftVehInfo(v->engine_type);

   428

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

   429

		return CMD_ERROR;

   430

   431

	switch (new_cargo_type) {

   432

		case CT_PASSENGERS:

   433

			pass = avi->passenger_capacity;

   434

			break;

   435

		case CT_MAIL:

   436

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

   437

			break;

   438

		case CT_GOODS:

   439

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

   440

			pass /= 2;

   441

			break;

   442

		default:

   443

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

   444

			pass /= 4;

   445

			break;

   446

	}

   447

	_aircraft_refit_capacity = pass;

   448

   449

	cost = 0;

   450

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

   451

		cost = _price.aircraft_base >> 7;

   452

	}

   453

   454

	if (flags & DC_EXEC) {

   455

		v->cargo_cap = pass;

   456

   457

		u = v->next;

   458

		mail = avi->mail_capacity;

   459

		if (new_cargo_type != CT_PASSENGERS) {

   460

			mail = 0;

   461

		}

   462

		u->cargo_cap = mail;

   463

		//autorefitted planes wants to keep the cargo

   464

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

   465

		if (!(SkipStoppedInHangerCheck))

   466

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

   467

		v->cargo_type = new_cargo_type;

   468

		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);

   469

	}

   470

   471

	return cost;

   472

}

   473

   474

void HandleClickOnAircraft(Vehicle *v)

   475

{

   476

	ShowAircraftViewWindow(v);

   477

}

   478

   479

static void CheckIfAircraftNeedsService(Vehicle *v)

   480

{

   481

	Station *st;

   482

   483

	if (_patches.servint_aircraft == 0)

   484

		return;

   485

   486

	if (!VehicleNeedsService(v))

   487

		return;

   488

   489

	if (v->vehstatus & VS_STOPPED)

   490

		return;

   491

   492

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

   493

			v->current_order.flags & OF_FULL_LOAD)

   494

		return;

   495

   496

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

   497

 		return;

   498

   499

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

   500

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

   501

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

   502

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

   503

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

   504

		v->current_order.type = OT_GOTO_DEPOT;

   505

		v->current_order.flags = OF_NON_STOP;

   506

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

   507

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

   508

		v->current_order.type = OT_DUMMY;

   509

		v->current_order.flags = 0;

   510

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

   511

	}

   512

}

   513