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

			_ptr_to_next_order >= endof(_order_array))

   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

		_ptr_to_next_order->type = OT_NOTHING;

   204

		_ptr_to_next_order->flags = 0;

   205

		v->schedule_ptr = _ptr_to_next_order++;

   206

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

   207

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

   208

		// On hold for NewAI

   209

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

   210

   211

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

   212

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

   213

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

   214

		*/

   215

		{

   216

			Station *st;

   217

			const AirportFTAClass *Airport;

   218

			const TileIndexDiffC *cur_depot;

   219

			byte i = 0;

   220

			st = GetStation(_map2[tile]);

   221

			Airport = GetAirport(st->airport_type);

   222

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

   223

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

   224

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

   225

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

   226

					break;

   227

				}

   228

				i++;

   229

			}

   230

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

   231

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

   232

		}

   233

   234

		v->u.air.state = HANGAR;

   235

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

   236

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

   237

		v->next = u;

   238

   239

		v->service_interval = _patches.servint_aircraft;

   240

   241

		v->date_of_last_service = _date;

   242

		v->build_year = _cur_year;

   243

   244

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

   245

   246

		VehiclePositionChanged(v);

   247

		VehiclePositionChanged(u);

   248

   249

		// Aircraft with 3 vehicles?

   250

		if (v->subtype == 0) {

   251

			w = vl[2];

   252

   253

			u->next = w;

   254

   255

			w->type = VEH_Aircraft;

   256

			w->direction = 0;

   257

			w->owner = _current_player;

   258

			w->x_pos = v->x_pos;

   259

			w->y_pos = v->y_pos;

   260

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

   261

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

   262

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

   263

			w->z_height = 1;

   264

			w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE;

   265

			w->subtype = 6;

   266

			w->cur_image = 0xF3D;

   267

			VehiclePositionChanged(w);

   268

		}

   269

   270

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   271

		RebuildVehicleLists();

   272

		InvalidateWindow(WC_COMPANY, v->owner);

   273

	}

   274

   275

	return value;

   276

}

   277

   278

bool IsAircraftHangarTile(TileIndex tile)

   279

{

   280

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

   281

	// 0x20 - hangar large airport (32)

   282

	// 0x41 - hangar small airport (65)

   283

	return IS_TILETYPE(tile, MP_STATION) &&

   284

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

   285

}

   286

   287

static bool CheckStoppedInHangar(Vehicle *v)

   288

{

   289

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

   290

			!IsAircraftHangarTile(v->tile)) {

   291

		_error_message = STR_A01B_AIRCRAFT_MUST_BE_STOPPED;

   292

		return false;

   293

	}

   294

   295

	return true;

   296

}

   297

   298

   299

static void DoDeleteAircraft(Vehicle *v)

   300

{

   301

	DeleteWindowById(WC_VEHICLE_VIEW, v->index);

   302

	RebuildVehicleLists();

   303

	InvalidateWindow(WC_COMPANY, v->owner);

   304

	DeleteVehicleChain(v);

   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

	return -(int32)v->value;

   328

}

   329

   330

// p1 = vehicle

   331

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

   332

{

   333

	Vehicle *v;

   334

   335

	v = GetVehicle(p1);

   336

   337

	if (!CheckOwnership(v->owner))

   338

		return CMD_ERROR;

   339

   340

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

   341

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

   342

		return_cmd_error(STR_A017_AIRCRAFT_IS_IN_FLIGHT);

   343

	}

   344

   345

	if (flags & DC_EXEC) {

   346

		v->vehstatus ^= VS_STOPPED;

   347

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

   348

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   349

	}

   350

   351

	return 0;

   352

}

   353

   354

// p1 = vehicle

   355

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

   356

{

   357

	Vehicle *v;

   358

	Station *st;

   359

   360

	v = GetVehicle(p1);

   361

   362

	if (!CheckOwnership(v->owner))

   363

		return CMD_ERROR;

   364

   365

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

   366

		if (flags & DC_EXEC) {

   367

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

   368

			v->current_order.type = OT_DUMMY;

   369

			v->current_order.flags = 0;

   370

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

   371

		}

   372

	} else {

   373

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

   374

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

   375

		// it surely doesn't have any hangars

   376

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

   377

					return CMD_ERROR;

   378

   379

		if (flags & DC_EXEC) {

   380

			v->current_order.type = OT_GOTO_DEPOT;

   381

			v->current_order.flags = OF_NON_STOP | OF_FULL_LOAD;

   382

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

   383

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

   384

		}

   385

	}

   386

   387

	return 0;

   388

}

   389

   390

// p1 = vehicle

   391

// p2 = new service int

   392

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

   393

{

   394

	Vehicle *v;

   395

   396

	v = GetVehicle(p1);

   397

   398

	if (!CheckOwnership(v->owner))

   399

		return CMD_ERROR;

   400

   401

	if (flags & DC_EXEC) {

   402

		v->service_interval = (uint16)p2;

   403

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

   404

	}

   405

   406

	return 0;

   407

}

   408

   409

// p1 = vehicle

   410

// p2 = new cargo type(0xFF)

   411

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

   412

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

   413

{

   414

	Vehicle *v,*u;

   415

	int pass, mail;

   416

	int32 cost;

   417

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

   418

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

   419

	AircraftVehicleInfo *avi;

   420

   421

	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN);

   422

   423

	v = GetVehicle(p1);

   424

	avi = AircraftVehInfo(v->engine_type);

   425

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

   426

		return CMD_ERROR;

   427

   428

	switch (new_cargo_type) {

   429

		case CT_PASSENGERS:

   430

			pass = avi->passenger_capacity;

   431

			break;

   432

		case CT_MAIL:

   433

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

   434

			break;

   435

		case CT_GOODS:

   436

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

   437

			pass /= 2;

   438

			break;

   439

		default:

   440

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

   441

			pass /= 4;

   442

			break;

   443

	}

   444

	_aircraft_refit_capacity = pass;

   445

   446

	cost = 0;

   447

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

   448

		cost = _price.aircraft_base >> 7;

   449

	}

   450

   451

	if (flags & DC_EXEC) {

   452

		v->cargo_cap = pass;

   453

   454

		u = v->next;

   455

		mail = avi->mail_capacity;

   456

		if (new_cargo_type != CT_PASSENGERS) {

   457

			mail = 0;

   458

		}

   459

		u->cargo_cap = mail;

   460

		//autorefitted planes wants to keep the cargo

   461

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

   462

		if (!(SkipStoppedInHangerCheck))

   463

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

   464

		v->cargo_type = new_cargo_type;

   465

		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);

   466

	}

   467

   468

	return cost;

   469

}

   470

   471

void HandleClickOnAircraft(Vehicle *v)

   472

{

   473

	ShowAircraftViewWindow(v);

   474

}

   475

   476

static void CheckIfAircraftNeedsService(Vehicle *v)

   477

{

   478

	Station *st;

   479

   480

	if (_patches.servint_aircraft == 0)

   481

		return;

   482

   483

	if (!VehicleNeedsService(v))

   484

		return;

   485

   486

	if (v->vehstatus & VS_STOPPED)

   487

		return;

   488

   489

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

   490

			v->current_order.flags & OF_FULL_LOAD)

   491

		return;

   492

   493

 	if (_patches.gotodepot && ScheduleHasDepotOrders(v->schedule_ptr))

   494

 		return;

   495

   496

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

   497

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

   498

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

   499

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

   500

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

   501

		v->current_order.type = OT_GOTO_DEPOT;

   502

		v->current_order.flags = OF_NON_STOP;

   503

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

   504

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

   505

		v->current_order.type = OT_DUMMY;

   506

		v->current_order.flags = 0;

   507

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

   508

	}

   509

}

   510