1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "vehicle.h"

     4

#include "engine.h"

     5

#include "command.h"

     6

#include "station.h"

     7

#include "news.h"

     8

#include "gfx.h"

     9

#include "player.h"

    10

#include "airport.h"

    11

    12

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

    13

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

    14

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

    15

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

    16

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

    17

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

    18

    19

static void AircraftNextAirportPos_and_Order(Vehicle *v);

    20

static byte GetAircraftFlyingAltitude(const Vehicle *v);

    21

    22

static const SpriteID _aircraft_sprite[] = {

    23

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

    24

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

    25

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

    26

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

    27

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

    28

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

    29

	0x0EBD, 0x0EC5

    30

};

    31

    32

int GetAircraftImage(Vehicle *v, byte direction)

    33

{

    34

	int spritenum = v->spritenum;

    35

    36

#ifdef AIRCRAFT_CUSTOM_SPRITES // TODO --pasky

    37

	if (is_custom_sprite(spritenum)) {

    38

		int sprite = GetCustomVehicleSprite(v, direction);

    39

    40

		if (sprite) return sprite;

    41

		spritenum = _engine_original_sprites[v->engine_type];

    42

	}

    43

#endif

    44

	return direction + _aircraft_sprite[spritenum];

    45

}

    46

    47

const byte _aircraft_cost_table[NUM_AIRCRAFT_ENGINES] = {

    48

	14, 15, 16, 75, 15, 18, 17, 18,

    49

	19, 20, 16, 18, 17, 30, 18, 19,

    50

	27, 25, 20, 19, 18, 26, 16, 17,

    51

	16, 16, 17, 18, 20, 21, 19, 24,

    52

	80, 13, 18, 25, 32, 80, 15, 17,

    53

	15

    54

};

    55

    56

const byte _aircraft_speed[NUM_AIRCRAFT_ENGINES] = {

    57

	37, 37, 74, 181, 37, 74, 74, 74,

    58

	74, 74, 74, 74, 74, 74, 74, 74,

    59

	74, 74, 74, 74, 74, 74, 74, 74,

    60

	74, 74, 74, 74, 74, 74, 181, 74,

    61

	181, 37, 37, 74, 74, 181, 25, 40,

    62

	25

    63

};

    64

    65

const byte _aircraft_running_cost[NUM_AIRCRAFT_ENGINES] = {

    66

	85, 100, 130, 250, 98, 240, 150, 245,

    67

	192, 190, 135, 240, 155, 253, 210, 220,

    68

	230, 225, 235, 220, 170, 210, 125, 145,

    69

	130, 149, 170, 210, 230, 220, 160, 248,

    70

	251, 85, 100, 140, 220, 255, 81, 77,

    71

	80

    72

};

    73

    74

const byte _aircraft_num_mail[NUM_AIRCRAFT_ENGINES] = {

    75

	 4,  8, 10, 20,  6, 30, 15, 30,

    76

	40, 25, 10, 35, 15, 50, 25, 25,

    77

	40, 35, 30, 25, 20, 20, 10, 10,

    78

	10, 10, 18, 25, 60, 65, 45, 80,

    79

	45,  5,  9, 12, 40, 30, 15, 20,

    80

	10

    81

};

    82

    83

const uint16 _aircraft_num_pass[NUM_AIRCRAFT_ENGINES] = {

    84

	 25, 65, 90,100, 30,200,100,150,

    85

	220,230, 95,170,110,300,200,240,

    86

	260,240,260,210,160,220, 80, 85,

    87

	 75, 85, 65,110,180,150, 85,400,

    88

	130, 25, 60, 90,200,100, 40, 55,

    89

	 40

    90

};

    91

    92

const byte _aircraft_sounds[NUM_AIRCRAFT_ENGINES] = {

    93

	 6,  6,  7, 59,  6,  7,  7,  7,

    94

	 7,  7,  7,  7,  7, 61,  7,  7,

    95

	 7,  7,  7,  7,  7,  7,  7,  7,

    96

	 7,  7,  7,  7,  7,  7,  7, 61,

    97

	59, 69, 70,  7, 61, 59,  7,  7,

    98

	 7

    99

};

   100

   101

const byte _aircraft_table_3[NUM_AIRCRAFT_ENGINES] = {

   102

	 1,  0,  2,  8,  5,  6,  2,  2,

   103

	 3,  3,  2,  2,  4,  7,  4,  4,

   104

	 4,  3,  4,  4,  4,  4,  6,  2,

   105

	11, 10, 15, 12, 13, 14, 16, 17,

   106

	18, 20, 21, 22, 23, 24,  9, 19,

   107

	25

   108

};

   109

   110

// &1 = regular aircraft

   111

// &2 = crashes easily on small airports

   112

const byte _aircraft_subtype[NUM_AIRCRAFT_ENGINES] = {

   113

	1,  1,  3,  3,  1,  3,  1,  3,

   114

	3,  3,  3,  3,  3,  3,  3,  3,

   115

	3,  3,  3,  3,  3,  3,  1,  1,

   116

	3,  3,  3,  3,  3,  3,  3,  3,

   117

	3,  1,  1,  1,  3,  3,  0,  0,

   118

	0

   119

};

   120

   121

const byte _aircraft_acceleration[NUM_AIRCRAFT_ENGINES] = {

   122

	18, 20, 35, 50, 20, 40, 35, 40,

   123

	40, 40, 35, 40, 40, 40, 40, 40,

   124

	40, 40, 40, 40, 40, 40, 50, 40,

   125

	40, 40, 40, 40, 40, 40, 40, 40,

   126

	50, 18, 20, 40, 40, 50, 20, 20,

   127

	20,

   128

};

   129

   130

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

   131

{

   132

	DrawSprite((6 + _aircraft_sprite[_aircraft_table_3[engine - AIRCRAFT_ENGINES_INDEX]]) | image_ormod, x, y);

   133

   134

	if ((_aircraft_subtype[engine - AIRCRAFT_ENGINES_INDEX]&1) == 0)

   135

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

   136

}

   137

   138

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

   139

{

   140

	engine -= AIRCRAFT_ENGINES_INDEX;

   141

   142

	SET_DPARAM32(0, ((_price.aircraft_base >> 3) * _aircraft_cost_table[engine]) >> 5);

   143

	SET_DPARAM16(1, _aircraft_speed[engine] << 3);

   144

	SET_DPARAM16(2, _aircraft_num_pass[engine]);

   145

	SET_DPARAM16(3, _aircraft_num_mail[engine]);

   146

	SET_DPARAM32(4, _aircraft_running_cost[engine] * _price.aircraft_running >> 8);

   147

   148

	DrawStringMultiCenter(x, y, STR_A02E_COST_MAX_SPEED_CAPACITY, maxw);

   149

}

   150

   151

/* Allocate many vehicles */

   152

bool AllocateVehicles(Vehicle **vl, int num)

   153

{

   154

	int i;

   155

	Vehicle *v;

   156

	bool success = true;

   157

   158

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

   159

		vl[i] = v = AllocateVehicle();

   160

		if (v == NULL) {

   161

			success = false;

   162

			break;

   163

		}

   164

		v->type = 1;

   165

	}

   166

   167

	while (--i >= 0) {

   168

		vl[i]->type = 0;

   169

	}

   170

   171

	return success;

   172

}

   173

   174

static int32 EstimateAircraftCost(uint16 engine_type)

   175

{

   176

	return _aircraft_cost_table[engine_type - AIRCRAFT_ENGINES_INDEX] * (_price.aircraft_base>>3)>>5;

   177

}

   178

   179

   180

/* p1 = engine */

   181

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

   182

{

   183

	int32 value;

   184

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

   185

	byte unit_num;

   186

	uint tile = TILE_FROM_XY(x,y);

   187

	Engine *e;

   188

   189

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   190

   191

	value = EstimateAircraftCost(p1);

   192

   193

	if (flags & DC_QUERY_COST)

   194

		return value;

   195

   196

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

   197

	if (!AllocateVehicles(vl, (_aircraft_subtype[p1 - AIRCRAFT_ENGINES_INDEX]&1) == 0 ? 3 : 2) ||

   198

			_ptr_to_next_order >= endof(_order_array))

   199

					return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   200

   201

	unit_num = GetFreeUnitNumber(VEH_Aircraft);

   202

	if (unit_num > _patches.max_aircraft)

   203

		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   204

   205

	if (flags & DC_EXEC) {

   206

		v = vl[0];

   207

		u = vl[1];

   208

   209

		v->unitnumber = unit_num;

   210

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

   211

		v->direction = 3;

   212

   213

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

   214

   215

		v->tile = tile;

   216

//		u->tile = 0;

   217

   218

		x = GET_TILE_X(tile)*16 + 5;

   219

		y = GET_TILE_Y(tile)*16 + 3;

   220

   221

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

   222

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

   223

   224

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

   225

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

   226

   227

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

   228

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

   229

   230

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

   231

		v->z_height = 5;

   232

   233

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

   234

		u->z_height = 1;

   235

   236

		v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

   237

		u->vehstatus = VS_HIDDEN | VS_UNCLICKABLE | VS_DISASTER;

   238

   239

		v->spritenum = _aircraft_table_3[p1 - AIRCRAFT_ENGINES_INDEX];

   240

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

   241

   242

		v->cargo_cap = _aircraft_num_pass[p1 - AIRCRAFT_ENGINES_INDEX];

   243

		u->cargo_cap = _aircraft_num_mail[p1 - AIRCRAFT_ENGINES_INDEX];

   244

   245

		v->cargo_type = CT_PASSENGERS;

   246

		u->cargo_type = CT_MAIL;

   247

   248

		v->string_id = STR_SV_AIRCRAFT_NAME;

   249

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

   250

   251

//		v->load_unload_time_rem = 0;

   252

//		v->progress = 0;

   253

		v->last_station_visited = 0xFF;

   254

//		v->destination_coords = 0;

   255

   256

		v->max_speed = _aircraft_speed[p1 - AIRCRAFT_ENGINES_INDEX];

   257

		v->acceleration = _aircraft_acceleration[p1 - AIRCRAFT_ENGINES_INDEX];

   258

		v->engine_type = (byte)p1;

   259

   260

		v->subtype = (_aircraft_subtype[p1 - AIRCRAFT_ENGINES_INDEX]&1) == 0 ? 0 : 2;

   261

		v->value = value;

   262

   263

		u->subtype = 4;

   264

   265

		e = &_engines[p1];

   266

		v->reliability = e->reliability;

   267

		v->reliability_spd_dec = e->reliability_spd_dec;

   268

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

   269

   270

		_new_aircraft_id = v->index;

   271

   272

		*(v->schedule_ptr = _ptr_to_next_order++) = 0;

   273

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

   274

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

   277

   278

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

   279

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

   280

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

   281

		*/

   282

		{

   283

			Station *st;

   284

			const AirportFTAClass *Airport;

   285

			const uint16 *cur_depot;

   286

			byte i = 0;

   287

			st = DEREF_STATION(_map2[tile]);

   288

			Airport = GetAirport(st->airport_type);

   289

			// first element of depot array contains #of depots on the airport

   290

			for (cur_depot=&Airport->airport_depots[1]; i != Airport->airport_depots[0]; cur_depot++) {

   291

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

   292

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

   293

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

   294

					break;

   295

				}

   296

				i++;

   297

			}

   298

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

   299

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

   300

		}

   301

   302

		v->u.air.state = HANGAR;

   303

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

   304

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

   305

		v->next = u;

   306

   307

		v->service_interval = _patches.servint_aircraft;

   308

   309

		v->date_of_last_service = _date;

   310

		v->build_year = _cur_year;

   311

   312

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

   313

   314

		VehiclePositionChanged(v);

   315

		VehiclePositionChanged(u);

   316

   317

		// Aircraft with 3 vehicles?

   318

		if (v->subtype == 0) {

   319

			w = vl[2];

   320

   321

			u->next = w;

   322

   323

			w->type = VEH_Aircraft;

   324

			w->direction = 0;

   325

			w->owner = _current_player;

   326

			w->x_pos = v->x_pos;

   327

			w->y_pos = v->y_pos;

   328

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

   329

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

   330

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

   331

			w->z_height = 1;

   332

			w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE;

   333

			w->subtype = 6;

   334

			w->cur_image = 0xF3D;

   335

			VehiclePositionChanged(w);

   336

		}

   337

   338

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   339

		InvalidateWindow(WC_AIRCRAFT_LIST, v->owner);

   340

		InvalidateWindow(WC_COMPANY, v->owner);

   341

	}

   342

   343

	return value;

   344

}

   345

   346

bool IsAircraftHangarTile(TileIndex tile)

   347

{

   348

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

   349

	// 0x20 - hangar large airport (32)

   350

	// 0x41 - hangar small airport (65)

   351

	return IS_TILETYPE(tile, MP_STATION) &&

   352

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

   353

}

   354

   355

static bool CheckStoppedInHangar(Vehicle *v)

   356

{

   357

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

   358

			!IsAircraftHangarTile(v->tile)) {

   359

		_error_message = STR_A01B_AIRCRAFT_MUST_BE_STOPPED;

   360

		return false;

   361

	}

   362

   363

	return true;

   364

}

   365

   366

   367

void DoDeleteAircraft(Vehicle *v)

   368

{

   369

	DeleteWindowById(WC_VEHICLE_VIEW, v->index);

   370

	InvalidateWindow(WC_AIRCRAFT_LIST, v->owner);

   371

	InvalidateWindow(WC_COMPANY, v->owner);

   372

	DeleteVehicleChain(v);

   373

}

   374

   375

// p1 = vehicle

   376

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

   377

{

   378

	Vehicle *v;

   379

   380

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   381

   382

	v = &_vehicles[p1];

   383

   384

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

   385

		return CMD_ERROR;

   386

   387

	if (flags & DC_EXEC) {

   388

		// Invalidate depot

   389

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   390

   391

		DoDeleteAircraft(v);

   392

   393

	}

   394

   395

	return -(int32)v->value;

   396

}

   397

   398

// p1 = vehicle

   399

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

   400

{

   401

	Vehicle *v;

   402

   403

	v = &_vehicles[p1];

   404

   405

	if (!CheckOwnership(v->owner))

   406

		return CMD_ERROR;

   407

   408

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

   409

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

   410

		return_cmd_error(STR_A017_AIRCRAFT_IS_IN_FLIGHT);

   411

	}

   412

   413

	if (flags & DC_EXEC) {

   414

		v->vehstatus ^= VS_STOPPED;

   415

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

   416

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   417

	}

   418

   419

	return 0;

   420

}

   421

   422

// p1 = vehicle

   423

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

   424

{

   425

	Vehicle *v;

   426

	Station *st;

   427

   428

	v = &_vehicles[p1];

   429

   430

	if (!CheckOwnership(v->owner))

   431

		return CMD_ERROR;

   432

   433

	if ((v->next_order&OT_MASK) == OT_GOTO_DEPOT) {

   434

		if (flags & DC_EXEC) {

   435

 			if (v->next_order&OF_UNLOAD)

   436

 				{ v->cur_order_index++; }

   437

			v->next_order = OT_DUMMY;

   438

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

   439

		}

   440

	} else {

   441

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

   442

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

   443

		// it surely doesn't have any hangars

   444

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

   445

					return CMD_ERROR;

   446

   447

		if (flags & DC_EXEC) {

   448

			v->next_order = OF_NON_STOP | OF_FULL_LOAD | OT_GOTO_DEPOT;

   449

			v->next_order_param = v->u.air.targetairport;

   450

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

   451

		}

   452

	}

   453

   454

	return 0;

   455

}

   456

   457

// p1 = vehicle

   458

// p2 = new service int

   459

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

   460

{

   461

	Vehicle *v;

   462

   463

	v = &_vehicles[p1];

   464

   465

	if (!CheckOwnership(v->owner))

   466

		return CMD_ERROR;

   467

   468

	if (flags & DC_EXEC) {

   469

		v->service_interval = (uint16)p2;

   470

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

   471

	}

   472

   473

	return 0;

   474

}

   475

   476

// p1 = vehicle

   477

// p2 = new cargo type

   478

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

   479

{

   480

	Vehicle *v,*u;

   481

	int pass, mail;

   482

	int32 cost;

   483

   484

	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN);

   485

   486

	v = &_vehicles[p1];

   487

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

   488

		return CMD_ERROR;

   489

   490

	pass = _aircraft_num_pass[v->engine_type - AIRCRAFT_ENGINES_INDEX];

   491

	if (p2 != 0) {

   492

		pass >>= 1;

   493

		if (p2 != 5)

   494

			pass >>= 1;

   495

	}

   496

	_aircraft_refit_capacity = pass;

   497

   498

	cost = 0;

   499

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

   500

		cost = _price.aircraft_base >> 7;

   501

	}

   502

   503

	if (flags & DC_EXEC) {

   504

		v->cargo_cap = pass;

   505

   506

		u = v->next;

   507

		mail = _aircraft_num_mail[v->engine_type - AIRCRAFT_ENGINES_INDEX];

   508

		if (p2 != 0) {

   509

			mail = 0;

   510

		}

   511

		u->cargo_cap = mail;

   512

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

   513

		v->cargo_type = (byte)p2;

   514

		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);

   515

	}

   516

   517

	return cost;

   518

}

   519

   520

void HandleClickOnAircraft(Vehicle *v)

   521

{

   522

	ShowAircraftViewWindow(v);

   523

}

   524

   525

static void CheckIfAircraftNeedsService(Vehicle *v)

   526

{

   527

	Station *st;

   528

   529

	if (_patches.servint_aircraft == 0)