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

	return value;

   273

}

   274

   275

bool IsAircraftHangarTile(TileIndex tile)

   276

{

   277

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

   278

	// 0x20 - hangar large airport (32)

   279

	// 0x41 - hangar small airport (65)

   280

	return IsTileType(tile, MP_STATION) &&

   281

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

   282

}

   283

   284

static bool CheckStoppedInHangar(Vehicle *v)

   285

{

   286

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

   287

			!IsAircraftHangarTile(v->tile)) {

   288

		_error_message = STR_A01B_AIRCRAFT_MUST_BE_STOPPED;

   289

		return false;

   290

	}

   291

   292

	return true;

   293

}

   294

   295

   296

static void DoDeleteAircraft(Vehicle *v)

   297

{

   298

	DeleteWindowById(WC_VEHICLE_VIEW, v->index);

   299

	RebuildVehicleLists();

   300

	InvalidateWindow(WC_COMPANY, v->owner);

   301

	DeleteVehicleChain(v);

   302

	InvalidateWindowClasses(WC_AIRCRAFT_LIST);

   303

}

   304

   305

// p1 = vehicle

   306

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

   307

{

   308

	Vehicle *v;

   309

   310

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   311

   312

	v = GetVehicle(p1);

   313

   314

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

   315

		return CMD_ERROR;

   316

   317

	if (flags & DC_EXEC) {

   318

		// Invalidate depot

   319

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   320

   321

		DoDeleteAircraft(v);

   322

   323

	}

   324

   325

	return -(int32)v->value;

   326

}

   327

   328

// p1 = vehicle

   329

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

   330

{

   331

	Vehicle *v;

   332

   333

	v = GetVehicle(p1);

   334

   335

	if (!CheckOwnership(v->owner))

   336

		return CMD_ERROR;

   337

   338

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

   339

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

   340

		return_cmd_error(STR_A017_AIRCRAFT_IS_IN_FLIGHT);

   341

	}

   342

   343

	if (flags & DC_EXEC) {

   344

		v->vehstatus ^= VS_STOPPED;

   345

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

   346

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   347

		InvalidateWindowClasses(WC_AIRCRAFT_LIST);

   348

	}

   349

   350

	return 0;

   351

}

   352

   353

// p1 = vehicle

   354

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

   355

{

   356

	Vehicle *v;

   357

	Station *st;

   358

   359

	v = GetVehicle(p1);

   360

   361

	if (!CheckOwnership(v->owner))

   362

		return CMD_ERROR;

   363

   364

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

   365

		if (flags & DC_EXEC) {

   366

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

   367

			v->current_order.type = OT_DUMMY;

   368

			v->current_order.flags = 0;

   369

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

   370

		}

   371

	} else {

   372

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

   373

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

   374

		// it surely doesn't have any hangars

   375

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

   376

					return CMD_ERROR;

   377

   378

		if (flags & DC_EXEC) {

   379

			v->current_order.type = OT_GOTO_DEPOT;

   380

			v->current_order.flags = OF_NON_STOP | OF_FULL_LOAD;

   381

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

   382

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

   383

		}

   384

	}

   385

   386

	return 0;

   387

}

   388

   389

// p1 = vehicle

   390

// p2 = new service int

   391

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

   392

{

   393

	Vehicle *v;

   394

   395

	v = GetVehicle(p1);

   396

   397

	if (!CheckOwnership(v->owner))

   398

		return CMD_ERROR;

   399

   400

	if (flags & DC_EXEC) {

   401

		v->service_interval = (uint16)p2;

   402

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

   403

	}

   404

   405

	return 0;

   406

}

   407

   408

// p1 = vehicle

   409

// p2 = new cargo type(0xFF)

   410

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

   411

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

   412

{

   413

	Vehicle *v,*u;

   414

	int pass, mail;

   415

	int32 cost;

   416

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

   417

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

   418

	AircraftVehicleInfo *avi;

   419

   420

	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN);

   421

   422

	v = GetVehicle(p1);

   423

	avi = AircraftVehInfo(v->engine_type);

   424

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

   425

		return CMD_ERROR;

   426

   427

	switch (new_cargo_type) {

   428

		case CT_PASSENGERS:

   429

			pass = avi->passenger_capacity;

   430

			break;

   431

		case CT_MAIL:

   432

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

   433

			break;

   434

		case CT_GOODS:

   435

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

   436

			pass /= 2;

   437

			break;

   438

		default:

   439

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

   440

			pass /= 4;

   441

			break;

   442

	}

   443

	_aircraft_refit_capacity = pass;

   444

   445

	cost = 0;

   446

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

   447

		cost = _price.aircraft_base >> 7;

   448

	}

   449

   450

	if (flags & DC_EXEC) {

   451

		v->cargo_cap = pass;

   452

   453

		u = v->next;

   454

		mail = avi->mail_capacity;

   455

		if (new_cargo_type != CT_PASSENGERS) {

   456

			mail = 0;

   457

		}

   458

		u->cargo_cap = mail;

   459

		//autorefitted planes wants to keep the cargo

   460

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

   461

		if (!(SkipStoppedInHangerCheck))

   462

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

   463

		v->cargo_type = new_cargo_type;

   464

		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);

   465

	}

   466

   467

	return cost;

   468

}

   469

   470

void HandleClickOnAircraft(Vehicle *v)

   471

{

   472

	ShowAircraftViewWindow(v);

   473

}

   474

   475

static void CheckIfAircraftNeedsService(Vehicle *v)

   476

{

   477

	Station *st;

   478

   479

	if (_patches.servint_aircraft == 0)

   480

		return;

   481

   482

	if (!VehicleNeedsService(v))

   483

		return;

   484

   485

	if (v->vehstatus & VS_STOPPED)

   486

		return;

   487

   488

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

   489

			v->current_order.flags & OF_FULL_LOAD)

   490

		return;

   491

   492

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

   493

 		return;

   494

   495

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

   496

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

   497

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

   498

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

   499

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

   500

		v->current_order.type = OT_GOTO_DEPOT;

   501

		v->current_order.flags = OF_NON_STOP;

   502

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

   503

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

   504

		v->current_order.type = OT_DUMMY;

   505

		v->current_order.flags = 0;

   506

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

   507

	}

   508

}

   509

   510

void OnNewDay_Aircraft(Vehicle *v)

   511

{

   512

	int32 cost;

   513

   514