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

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

   276

   277

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

   278

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

   279

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

   280

		*/

   281

		{

   282

			Station *st;

   283

			const AirportFTAClass *Airport;

   284

			const uint16 *cur_depot;

   285

			byte i = 0;

   286

			st = DEREF_STATION(_map2[tile]);

   287

			Airport = GetAirport(st->airport_type);

   288

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

   289

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

   290

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

   291

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

   292

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

   293

					break;

   294

				}

   295

				i++;

   296

			}

   297

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

   298

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

   299

		}

   300

   301

		v->u.air.state = HANGAR;

   302

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

   303

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

   304

		v->next = u;

   305

   306

		v->service_interval = _patches.servint_aircraft;

   307

   308

		v->date_of_last_service = _date;

   309

		v->build_year = _cur_year;

   310

   311

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

   312

   313

		VehiclePositionChanged(v);

   314

		VehiclePositionChanged(u);

   315

   316

		// Aircraft with 3 vehicles?

   317

		if (v->subtype == 0) {

   318

			w = vl[2];

   319

   320

			u->next = w;

   321

   322

			w->type = VEH_Aircraft;

   323

			w->direction = 0;

   324

			w->owner = _current_player;

   325

			w->x_pos = v->x_pos;

   326

			w->y_pos = v->y_pos;

   327

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

   328

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

   329

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

   330

			w->z_height = 1;

   331

			w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE;

   332

			w->subtype = 6;

   333

			w->cur_image = 0xF3D;

   334

			VehiclePositionChanged(w);

   335

		}

   336

   337

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   338

		InvalidateWindow(WC_AIRCRAFT_LIST, v->owner);

   339

		InvalidateWindow(WC_COMPANY, v->owner);

   340

	}

   341

   342

	return value;

   343

}

   344

   345

bool IsAircraftHangarTile(TileIndex tile)

   346

{

   347

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

   348

	// 0x20 - hangar large airport (32)

   349

	// 0x41 - hangar small airport (65)

   350

	return IS_TILETYPE(tile, MP_STATION) &&

   351

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

   352

}

   353

   354

static bool CheckStoppedInHangar(Vehicle *v)

   355

{

   356

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

   357

			!IsAircraftHangarTile(v->tile)) {

   358

		_error_message = STR_A01B_AIRCRAFT_MUST_BE_STOPPED;

   359

		return false;

   360

	}

   361

   362

	return true;

   363

}

   364

   365

   366

void DoDeleteAircraft(Vehicle *v)

   367

{

   368

	DeleteWindowById(WC_VEHICLE_VIEW, v->index);

   369

	InvalidateWindow(WC_AIRCRAFT_LIST, v->owner);

   370

	InvalidateWindow(WC_COMPANY, v->owner);

   371

	DeleteVehicleChain(v);

   372

}

   373

   374

// p1 = vehicle

   375

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

   376

{

   377

	Vehicle *v;

   378

   379

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   380

   381

	v = &_vehicles[p1];

   382

   383

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

   384

		return CMD_ERROR;

   385

   386

	if (flags & DC_EXEC) {

   387

		// Invalidate depot

   388

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   389

   390

		DoDeleteAircraft(v);

   391

   392

	}

   393

   394

	return -(int32)v->value;

   395

}

   396

   397

// p1 = vehicle

   398

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

   399

{

   400

	Vehicle *v;

   401

   402

	v = &_vehicles[p1];

   403

   404

	if (!CheckOwnership(v->owner))

   405

		return CMD_ERROR;

   406

   407

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

   408

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

   409

		return_cmd_error(STR_A017_AIRCRAFT_IS_IN_FLIGHT);

   410

	}

   411

   412

	if (flags & DC_EXEC) {

   413

		v->vehstatus ^= VS_STOPPED;

   414

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

   415

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   416

	}

   417

   418

	return 0;

   419

}

   420

   421

// p1 = vehicle

   422

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

   423

{

   424

	Vehicle *v;

   425

	Station *st;

   426

   427

	v = &_vehicles[p1];

   428

   429

	if (!CheckOwnership(v->owner))

   430

		return CMD_ERROR;

   431

   432

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

   433

		if (flags & DC_EXEC) {

   434

 			if (v->next_order&OF_UNLOAD)

   435

 				{ v->cur_order_index++; }

   436

			v->next_order = OT_DUMMY;

   437

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

   438

		}

   439

	} else {

   440

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

   441

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

   442

		// it surely doesn't have any hangars

   443

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

   444

					return CMD_ERROR;

   445

   446

		if (flags & DC_EXEC) {

   447

			v->next_order = OF_NON_STOP | OF_FULL_LOAD | OT_GOTO_DEPOT;

   448

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

   449

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

   450

		}

   451

	}

   452

   453

	return 0;

   454

}

   455

   456

// p1 = vehicle

   457

// p2 = new service int

   458

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

   459

{

   460

	Vehicle *v;

   461

   462

	v = &_vehicles[p1];

   463

   464

	if (!CheckOwnership(v->owner))

   465

		return CMD_ERROR;

   466

   467

	if (flags & DC_EXEC) {

   468

		v->service_interval = (uint16)p2;

   469

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

   470

	}

   471

   472

	return 0;

   473

}

   474

   475

// p1 = vehicle

   476

// p2 = new cargo type

   477

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

   478

{

   479

	Vehicle *v,*u;

   480

	int pass, mail;

   481

	int32 cost;

   482

   483

	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN);

   484

   485

	v = &_vehicles[p1];

   486

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

   487

		return CMD_ERROR;

   488

   489

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

   490

	if (p2 != 0) {

   491

		pass >>= 1;

   492

		if (p2 != 5)

   493

			pass >>= 1;

   494

	}

   495

	_aircraft_refit_capacity = pass;

   496

   497

	cost = 0;

   498

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

   499

		cost = _price.aircraft_base >> 7;

   500

	}

   501

   502

	if (flags & DC_EXEC) {

   503

		v->cargo_cap = pass;

   504

   505

		u = v->next;

   506

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

   507

		if (p2 != 0) {

   508

			mail = 0;

   509

		}

   510

		u->cargo_cap = mail;

   511

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

   512

		v->cargo_type = (byte)p2;

   513

		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);

   514

	}

   515

   516

	return cost;

   517

}

   518

   519

void HandleClickOnAircraft(Vehicle *v)

   520

{

   521

	ShowAircraftViewWindow(v);

   522

}

   523

   524

static void CheckIfAircraftNeedsService(Vehicle *v)

   525

{

   526

	Station *st;

   527

   528

	if (_patches.servint_aircraft == 0 && IS_HUMAN_PLAYER(v->owner))

   529

		return;