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

   275

		// On hold for NewAI

   276

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

   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

		_vehicle_sort_dirty[VEHAIRCRAFT] = true; // build aircraft

   340

		InvalidateWindow(WC_AIRCRAFT_LIST, v->owner);

   341

		InvalidateWindow(WC_COMPANY, v->owner);

   342

	}

   343

   344

	return value;

   345

}

   346

   347

bool IsAircraftHangarTile(TileIndex tile)

   348

{

   349

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

   350

	// 0x20 - hangar large airport (32)

   351

	// 0x41 - hangar small airport (65)

   352

	return IS_TILETYPE(tile, MP_STATION) &&

   353

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

   354

}

   355

   356

static bool CheckStoppedInHangar(Vehicle *v)

   357

{

   358

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

   359

			!IsAircraftHangarTile(v->tile)) {

   360

		_error_message = STR_A01B_AIRCRAFT_MUST_BE_STOPPED;

   361

		return false;

   362

	}

   363

   364

	return true;

   365

}

   366

   367

   368

void DoDeleteAircraft(Vehicle *v)

   369

{

   370

	DeleteWindowById(WC_VEHICLE_VIEW, v->index);

   371

	_vehicle_sort_dirty[VEHAIRCRAFT] = true; // delete aircraft

   372

	InvalidateWindow(WC_AIRCRAFT_LIST, v->owner);

   373

	InvalidateWindow(WC_COMPANY, v->owner);

   374

	DeleteVehicleChain(v);

   375

}

   376

   377

// p1 = vehicle

   378

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

   379

{

   380

	Vehicle *v;

   381

   382

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   383

   384

	v = &_vehicles[p1];

   385

   386

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

   387

		return CMD_ERROR;

   388

   389

	if (flags & DC_EXEC) {

   390

		// Invalidate depot

   391

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   392

   393

		DoDeleteAircraft(v);

   394

   395

	}

   396

   397

	return -(int32)v->value;

   398

}

   399

   400

// p1 = vehicle

   401

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

   402

{

   403

	Vehicle *v;

   404

   405

	v = &_vehicles[p1];

   406

   407

	if (!CheckOwnership(v->owner))

   408

		return CMD_ERROR;

   409

   410

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

   411

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

   412

		return_cmd_error(STR_A017_AIRCRAFT_IS_IN_FLIGHT);

   413

	}

   414

   415

	if (flags & DC_EXEC) {

   416

		v->vehstatus ^= VS_STOPPED;

   417

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

   418

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   419

	}

   420

   421

	return 0;

   422

}

   423

   424

// p1 = vehicle

   425

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

   426

{

   427

	Vehicle *v;

   428

	Station *st;

   429

   430

	v = &_vehicles[p1];

   431

   432

	if (!CheckOwnership(v->owner))

   433

		return CMD_ERROR;

   434

   435

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

   436

		if (flags & DC_EXEC) {

   437

 			if (v->next_order&OF_UNLOAD)

   438

 				{ v->cur_order_index++; }

   439

			v->next_order = OT_DUMMY;

   440

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

   441

		}

   442

	} else {

   443

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

   444

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

   445

		// it surely doesn't have any hangars

   446

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

   447

					return CMD_ERROR;

   448

   449

		if (flags & DC_EXEC) {

   450

			v->next_order = OF_NON_STOP | OF_FULL_LOAD | OT_GOTO_DEPOT;

   451

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

   452

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

   453

		}

   454

	}

   455

   456

	return 0;

   457

}

   458

   459

// p1 = vehicle

   460

// p2 = new service int

   461

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

   462

{

   463

	Vehicle *v;

   464

   465

	v = &_vehicles[p1];

   466

   467

	if (!CheckOwnership(v->owner))

   468

		return CMD_ERROR;

   469

   470

	if (flags & DC_EXEC) {

   471

		v->service_interval = (uint16)p2;

   472

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

   473

	}

   474

   475

	return 0;

   476

}

   477

   478

// p1 = vehicle

   479

// p2 = new cargo type

   480

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

   481

{

   482

	Vehicle *v,*u;

   483

	int pass, mail;

   484

	int32 cost;

   485

   486

	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN);

   487

   488

	v = &_vehicles[p1];

   489

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

   490

		return CMD_ERROR;

   491

   492

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

   493

	if (p2 != 0) {

   494

		pass >>= 1;

   495

		if (p2 != 5)

   496

			pass >>= 1;

   497

	}

   498

	_aircraft_refit_capacity = pass;

   499

   500

	cost = 0;

   501

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

   502

		cost = _price.aircraft_base >> 7;

   503

	}

   504

   505

	if (flags & DC_EXEC) {

   506

		v->cargo_cap = pass;

   507

   508

		u = v->next;

   509

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

   510

		if (p2 != 0) {

   511

			mail = 0;

   512

		}

   513

		u->cargo_cap = mail;

   514

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

   515

		v->cargo_type = (byte)p2;

   516

		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);

   517

	}

   518

   519

	return cost;

   520

}

   521

   522

void HandleClickOnAircraft(Vehicle *v)

   523

{

   524

	ShowAircraftViewWindow(v);

   525

}

   526

   527

static void CheckIfAircraftNeedsService(Vehicle *v)

   528

{

   529