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

    80

int GetAircraftImage(Vehicle *v, byte direction)

    81

{

    82

	int spritenum = v->spritenum;

    83

    84

	if (is_custom_sprite(spritenum)) {

    85

		int sprite = GetCustomVehicleSprite(v, direction);

    86

    87

		if (sprite) return sprite;

    88

		spritenum = _engine_original_sprites[v->engine_type];

    89

	}

    90

	return direction + _aircraft_sprite[spritenum];

    91

}

    92

    93

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

    94

{

    95

	int spritenum = AircraftVehInfo(engine)->image_index;

    96

    97

	if (is_custom_sprite(spritenum)) {

    98

		int sprite = GetCustomVehicleIcon(engine, 6);

    99

   100

		if (sprite) {

   101

			DrawSprite(sprite | image_ormod, x, y);

   102

			return;

   103

		}

   104

		spritenum = _engine_original_sprites[engine];

   105

	}

   106

   107

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

   108

   109

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

   110

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

   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

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   165

   166

	value = EstimateAircraftCost(p1);

   167

   168

	if (flags & DC_QUERY_COST)

   169

		return value;

   170

   171

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

   172

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

   173

				IsOrderPoolFull())

   174

					return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   175

   176

	unit_num = GetFreeUnitNumber(VEH_Aircraft);

   177

	if (unit_num > _patches.max_aircraft)

   178

		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   179

   180

	if (flags & DC_EXEC) {

   181

		v = vl[0];

   182

		u = vl[1];

   183

   184

		v->unitnumber = unit_num;

   185

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

   186

		v->direction = 3;

   187

   188

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

   189

   190

		v->tile = tile;

   191

//		u->tile = 0;

   192

   193

		x = TileX(tile) * 16 + 5;

   194

		y = TileY(tile) * 16 + 3;

   195

   196

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

   197

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

   198

   199

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

   200

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

   201

   202

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

   203

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

   204

   205

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

   206

		v->z_height = 5;

   207

   208

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

   209

		u->z_height = 1;

   210

   211

		v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

   212

		u->vehstatus = VS_HIDDEN | VS_UNCLICKABLE | VS_DISASTER;

   213

   214

		v->spritenum = avi->image_index;

   215

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

   216

   217

		v->cargo_cap = avi->passenger_capacity;

   218

		u->cargo_cap = avi->mail_capacity;

   219

   220

		v->cargo_type = CT_PASSENGERS;

   221

		u->cargo_type = CT_MAIL;

   222

   223

		v->string_id = STR_SV_AIRCRAFT_NAME;

   224

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

   225

   226

//		v->load_unload_time_rem = 0;

   227

//		v->progress = 0;

   228

		v->last_station_visited = 0xFFFF;

   229

//		v->destination_coords = 0;

   230

   231

		v->max_speed = avi->max_speed;

   232

		v->acceleration = avi->acceleration;

   233

		v->engine_type = (byte)p1;

   234

   235

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

   236

		v->value = value;

   237

   238

		u->subtype = 4;

   239

   240

		e = &_engines[p1];

   241

		v->reliability = e->reliability;

   242

		v->reliability_spd_dec = e->reliability_spd_dec;

   243

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

   244

   245

		_new_aircraft_id = v->index;

   246

   247

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

   248

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

   249

		// On hold for NewAI

   250

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

   251

   252

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

   253

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

   254

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

   255

		*/

   256

		{

   257

			Station *st;

   258

			const AirportFTAClass *Airport;

   259

			const TileIndexDiffC *cur_depot;

   260

			byte i = 0;

   261

			st = GetStation(_map2[tile]);

   262

			Airport = GetAirport(st->airport_type);

   263

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

   264

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

   265

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

   266

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

   267

					break;

   268

				}

   269

				i++;

   270

			}

   271

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

   272

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

   273

		}

   274

   275

		v->u.air.state = HANGAR;

   276

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

   277

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

   278

		v->next = u;

   279

   280

		v->service_interval = _patches.servint_aircraft;

   281

   282

		v->date_of_last_service = _date;

   283

		v->build_year = _cur_year;

   284

   285

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

   286

   287

		VehiclePositionChanged(v);

   288

		VehiclePositionChanged(u);

   289

   290

		// Aircraft with 3 vehicles?

   291

		if (v->subtype == 0) {

   292

			w = vl[2];

   293

   294

			u->next = w;

   295

   296

			w->type = VEH_Aircraft;

   297

			w->direction = 0;

   298

			w->owner = _current_player;

   299

			w->x_pos = v->x_pos;

   300

			w->y_pos = v->y_pos;

   301

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

   302

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

   303

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

   304

			w->z_height = 1;

   305

			w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE;

   306

			w->subtype = 6;

   307

			w->cur_image = 0xF3D;

   308

			VehiclePositionChanged(w);

   309

		}

   310

   311

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   312

		RebuildVehicleLists();

   313

		InvalidateWindow(WC_COMPANY, v->owner);

   314

	}

   315

   316

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

   317

   318

	return value;

   319

}

   320

   321

bool IsAircraftHangarTile(TileIndex tile)

   322

{

   323

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

   324

	// 0x20 - hangar large airport (32)

   325

	// 0x41 - hangar small airport (65)

   326

	return IsTileType(tile, MP_STATION) &&

   327

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

   328

}

   329

   330

static bool CheckStoppedInHangar(Vehicle *v)

   331

{

   332

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

   333

			!IsAircraftHangarTile(v->tile)) {

   334

		_error_message = STR_A01B_AIRCRAFT_MUST_BE_STOPPED;

   335

		return false;

   336

	}

   337

   338

	return true;

   339

}

   340

   341

   342

static void DoDeleteAircraft(Vehicle *v)

   343

{

   344

	DeleteWindowById(WC_VEHICLE_VIEW, v->index);

   345

	RebuildVehicleLists();

   346

	InvalidateWindow(WC_COMPANY, v->owner);

   347

	DeleteVehicleChain(v);

   348

	InvalidateWindowClasses(WC_AIRCRAFT_LIST);

   349

}

   350

   351

// p1 = vehicle

   352

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

   353

{

   354

	Vehicle *v;

   355

   356

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   357

   358

	v = GetVehicle(p1);

   359

   360

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

   361

		return CMD_ERROR;

   362

   363

	if (flags & DC_EXEC) {

   364

		// Invalidate depot

   365

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   366

   367

		DoDeleteAircraft(v);

   368

   369

	}

   370

   371

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

   372

   373

	return -(int32)v->value;

   374

}

   375

   376

// p1 = vehicle

   377

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

   378

{

   379

	Vehicle *v;

   380

   381

	v = GetVehicle(p1);

   382

   383

	if (!CheckOwnership(v->owner))

   384

		return CMD_ERROR;

   385

   386

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

   387

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

   388

		return_cmd_error(STR_A017_AIRCRAFT_IS_IN_FLIGHT);

   389

	}

   390

   391

	if (flags & DC_EXEC) {

   392

		v->vehstatus ^= VS_STOPPED;

   393

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

   394

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   395

		InvalidateWindowClasses(WC_AIRCRAFT_LIST);

   396

	}

   397

   398

	return 0;

   399

}

   400

   401

// p1 = vehicle

   402

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

   403

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

   404

{

   405

	Vehicle *v;

   406

	Station *st;

   408

   409

	v = GetVehicle(p1);

   410

   412

   413

	if (!CheckOwnership(v->owner))

   414

		return CMD_ERROR;

   415

   416

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

   417

		if (flags & DC_EXEC) {

   418

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

   419

			v->current_order.type = OT_DUMMY;

   420

			v->current_order.flags = 0;

   421

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

   422

		}

   423

	} else {

   426

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

   427

		// it surely doesn't have any hangars

   428

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

   429

					return CMD_ERROR;

   430

   431

		if (flags & DC_EXEC) {

   432

			v->current_order.type = OT_GOTO_DEPOT;

   435

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

   440

		}

   441

	}

   442

   443

	return 0;

   444

}

   445

   446

// p1 = vehicle

   447

// p2 = new service int

   448

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

   449

{

   450

	Vehicle *v;

   451

   452

	v = GetVehicle(p1);

   453

   454

	if (!CheckOwnership(v->owner))

   455

		return CMD_ERROR;

   456

   457

	if (flags & DC_EXEC) {

   458

		v->service_interval = (uint16)p2;

   459

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

   460

	}

   461

   462

	return 0;

   463

}

   464

   465

// p1 = vehicle

   466

// p2 = new cargo type(0xFF)

   467

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

   468

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

   469

{

   470

	Vehicle *v,*u;

   471

	int pass, mail;

   472

	int32 cost;

   473

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

   474

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

   475

	AircraftVehicleInfo *avi;

   476

   477

	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN);

   478

   479

	v = GetVehicle(p1);

   480

	avi = AircraftVehInfo(v->engine_type);

   481

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

   482

		return CMD_ERROR;

   483

   484

	switch (new_cargo_type) {

   485

		case CT_PASSENGERS:

   486

			pass = avi->passenger_capacity;

   487

			break;

   488

		case CT_MAIL:

   489

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

   490

			break;

   491

		case CT_GOODS:

   492

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

   493

			pass /= 2;

   494

			break;

   495

		default:

   496

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

   497

			pass /= 4;

   498

			break;

   499

	}

   500

	_aircraft_refit_capacity = pass;

   501

   502

	cost = 0;

   503

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

   504

		cost = _price.aircraft_base >> 7;

   505

	}

   506

   507

	if (flags & DC_EXEC) {

   508

		v->cargo_cap = pass;

   509

   510

		u = v->next;

   511

		mail = avi->mail_capacity;

   512