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 "sound.h"

    10

#include "player.h"

    11

#include "airport.h"

    12

    13

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

    14

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

    15

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

    16

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

    17

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

    18

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

    19

    20

static void AircraftNextAirportPos_and_Order(Vehicle *v);

    21

static byte GetAircraftFlyingAltitude(const Vehicle *v);

    22

    23

static const SpriteID _aircraft_sprite[] = {

    24

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

    25

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

    26

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

    27

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

    28

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

    29

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

    30

	0x0EBD, 0x0EC5

    31

};

    32

    33

int GetAircraftImage(Vehicle *v, byte direction)

    34

{

    35

	int spritenum = v->spritenum;

    36

    37

#ifdef AIRCRAFT_CUSTOM_SPRITES // TODO --pasky

    38

	if (is_custom_sprite(spritenum)) {

    39

		int sprite = GetCustomVehicleSprite(v, direction);

    40

    41

		if (sprite) return sprite;

    42

		spritenum = _engine_original_sprites[v->engine_type];

    43

	}

    44

#endif

    45

	return direction + _aircraft_sprite[spritenum];

    46

}

    47

    48

const byte _aircraft_cost_table[NUM_AIRCRAFT_ENGINES] = {

    49

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

    50

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

    51

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

    52

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

    53

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

    54

	15

    55

};

    56

    57

const byte _aircraft_speed[NUM_AIRCRAFT_ENGINES] = {

    58

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

    59

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

    60

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

    61

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

    62

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

    63

	25

    64

};

    65

    66

const byte _aircraft_running_cost[NUM_AIRCRAFT_ENGINES] = {

    67

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

    68

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

    69

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

    70

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

    71

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

    72

	80

    73

};

    74

    75

const byte _aircraft_num_mail[NUM_AIRCRAFT_ENGINES] = {

    76

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

    77

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

    78

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

    79

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

    80

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

    81

	10

    82

};

    83

    84

const uint16 _aircraft_num_pass[NUM_AIRCRAFT_ENGINES] = {

    85

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

    86

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

    87

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

    88

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

    89

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

    90

	 40

    91

};

    92

    93

const byte _aircraft_sounds[NUM_AIRCRAFT_ENGINES] = {

    94

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

    95

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

    96

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

    97

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

    98

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

    99

	 7

   100

};

   101

   102

const byte _aircraft_table_3[NUM_AIRCRAFT_ENGINES] = {

   103

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

   104

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

   105

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

   106

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

   107

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

   108

	25

   109

};

   110

   111

// &1 = regular aircraft

   112

// &2 = crashes easily on small airports

   113

const byte _aircraft_subtype[NUM_AIRCRAFT_ENGINES] = {

   114

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

   115

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

   116

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

   117

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

   118

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

   119

	0

   120

};

   121

   122

const byte _aircraft_acceleration[NUM_AIRCRAFT_ENGINES] = {

   123

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

   124

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

   125

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

   126

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

   127

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

   128

	20,

   129

};

   130

   131

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

   132

{

   133

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

   134

   135

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

   136

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

   137

}

   138

   139

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

   140

{

   141

	engine -= AIRCRAFT_ENGINES_INDEX;

   142

   143

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

   144

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

   145

	SET_DPARAM16(2, _aircraft_num_pass[engine]);

   146

	SET_DPARAM16(3, _aircraft_num_mail[engine]);

   147

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

   148

   149

	DrawStringMultiCenter(x, y, STR_A02E_COST_MAX_SPEED_CAPACITY, maxw);

   150

}

   151

   152

/* Allocate many vehicles */

   153

bool AllocateVehicles(Vehicle **vl, int num)

   154

{

   155

	int i;

   156

	Vehicle *v;

   157

	bool success = true;

   158

   159

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

   160

		vl[i] = v = AllocateVehicle();

   161

		if (v == NULL) {

   162

			success = false;

   163

			break;

   164

		}

   165

		v->type = 1;

   166

	}

   167

   168

	while (--i >= 0) {

   169

		vl[i]->type = 0;

   170

	}

   171

   172

	return success;

   173

}

   174

   175

static int32 EstimateAircraftCost(uint16 engine_type)

   176

{

   177

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

   178

}

   179

   180

   181

/* p1 = engine */

   182

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

   183

{

   184

	int32 value;

   185

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

   186

	byte unit_num;

   187

	uint tile = TILE_FROM_XY(x,y);

   188

	Engine *e;

   189

   190

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   191

   192

	value = EstimateAircraftCost(p1);

   193

   194

	if (flags & DC_QUERY_COST)

   195

		return value;

   196

   197

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

   198

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

   199

			_ptr_to_next_order >= endof(_order_array))

   200

					return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   201

   202

	unit_num = GetFreeUnitNumber(VEH_Aircraft);

   203

	if (unit_num > _patches.max_aircraft)

   204

		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   205

   206

	if (flags & DC_EXEC) {

   207

		v = vl[0];

   208

		u = vl[1];

   209

   210

		v->unitnumber = unit_num;

   211

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

   212

		v->direction = 3;

   213

   214

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

   215

   216

		v->tile = tile;

   217

//		u->tile = 0;

   218

   219

		x = GET_TILE_X(tile)*16 + 5;

   220

		y = GET_TILE_Y(tile)*16 + 3;

   221

   222

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

   223

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

   224

   225

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

   226

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

   227

   228

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

   229

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

   230

   231

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

   232

		v->z_height = 5;

   233

   234

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

   235

		u->z_height = 1;

   236

   237

		v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

   238

		u->vehstatus = VS_HIDDEN | VS_UNCLICKABLE | VS_DISASTER;

   239

   240

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

   241

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

   242

   243

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

   244

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

   245

   246

		v->cargo_type = CT_PASSENGERS;

   247

		u->cargo_type = CT_MAIL;

   248

   249

		v->string_id = STR_SV_AIRCRAFT_NAME;

   250

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

   251

   252

//		v->load_unload_time_rem = 0;

   253

//		v->progress = 0;

   254

		v->last_station_visited = 0xFF;

   255

//		v->destination_coords = 0;

   256

   257

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

   258

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

   259

		v->engine_type = (byte)p1;

   260

   261

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

   262

		v->value = value;

   263

   264

		u->subtype = 4;

   265

   266

		e = &_engines[p1];

   267

		v->reliability = e->reliability;

   268

		v->reliability_spd_dec = e->reliability_spd_dec;

   269

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

   270

   271

		_new_aircraft_id = v->index;

   272

   273

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

   274

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

   275

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

   276

		// On hold for NewAI

   277

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

   278

   279

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

   280

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

   281

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

   282

		*/

   283

		{

   284

			Station *st;

   285

			const AirportFTAClass *Airport;

   286

			const uint16 *cur_depot;

   287

			byte i = 0;

   288

			st = DEREF_STATION(_map2[tile]);

   289

			Airport = GetAirport(st->airport_type);

   290

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

   291

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

   292

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

   293

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

   294

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

   295

					break;

   296

				}

   297

				i++;

   298

			}

   299

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

   300

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

   301

		}

   302

   303

		v->u.air.state = HANGAR;

   304

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

   305

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

   306

		v->next = u;

   307

   308

		v->service_interval = _patches.servint_aircraft;

   309

   310

		v->date_of_last_service = _date;

   311

		v->build_year = _cur_year;

   312

   313

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

   314

   315

		VehiclePositionChanged(v);

   316

		VehiclePositionChanged(u);

   317

   318

		// Aircraft with 3 vehicles?

   319

		if (v->subtype == 0) {

   320

			w = vl[2];

   321

   322

			u->next = w;

   323

   324

			w->type = VEH_Aircraft;

   325

			w->direction = 0;

   326

			w->owner = _current_player;

   327

			w->x_pos = v->x_pos;

   328

			w->y_pos = v->y_pos;

   329

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

   330

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

   331

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

   332

			w->z_height = 1;

   333

			w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE;

   334

			w->subtype = 6;

   335

			w->cur_image = 0xF3D;

   336

			VehiclePositionChanged(w);

   337

		}

   338

   339

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   340

		_vehicle_sort_dirty[VEHAIRCRAFT] = true; // build aircraft

   341

		InvalidateWindow(WC_AIRCRAFT_LIST, v->owner);

   342

		InvalidateWindow(WC_COMPANY, v->owner);

   343

	}

   344

   345

	return value;

   346

}

   347

   348

bool IsAircraftHangarTile(TileIndex tile)

   349

{

   350

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

   351

	// 0x20 - hangar large airport (32)

   352

	// 0x41 - hangar small airport (65)

   353

	return IS_TILETYPE(tile, MP_STATION) &&

   354

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

   355

}

   356

   357

static bool CheckStoppedInHangar(Vehicle *v)

   358

{

   359

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

   360

			!IsAircraftHangarTile(v->tile)) {

   361

		_error_message = STR_A01B_AIRCRAFT_MUST_BE_STOPPED;

   362

		return false;

   363

	}

   364

   365

	return true;

   366

}

   367

   368

   369

void DoDeleteAircraft(Vehicle *v)

   370

{

   371

	DeleteWindowById(WC_VEHICLE_VIEW, v->index);

   372

	_vehicle_sort_dirty[VEHAIRCRAFT] = true; // delete aircraft

   373

	InvalidateWindow(WC_AIRCRAFT_LIST, v->owner);

   374

	InvalidateWindow(WC_COMPANY, v->owner);

   375

	DeleteVehicleChain(v);

   376

}

   377

   378

// p1 = vehicle

   379

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

   380

{

   381

	Vehicle *v;

   382

   383

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   384

   385

	v = &_vehicles[p1];

   386

   387

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

   388

		return CMD_ERROR;

   389

   390

	if (flags & DC_EXEC) {

   391

		// Invalidate depot

   392

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   393

   394

		DoDeleteAircraft(v);

   395

   396

	}

   397

   398

	return -(int32)v->value;

   399

}

   400

   401

// p1 = vehicle

   402

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

   403

{

   404

	Vehicle *v;

   405

   406

	v = &_vehicles[p1];

   407

   408

	if (!CheckOwnership(v->owner))

   409

		return CMD_ERROR;

   410

   411

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

   412

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

   413

		return_cmd_error(STR_A017_AIRCRAFT_IS_IN_FLIGHT);

   414

	}

   415

   416

	if (flags & DC_EXEC) {

   417

		v->vehstatus ^= VS_STOPPED;

   418

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

   419

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   420

	}

   421

   422

	return 0;

   423

}

   424

   425

// p1 = vehicle

   426

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

   427

{

   428

	Vehicle *v;

   429

	Station *st;

   430

   431

	v = &_vehicles[p1];

   432

   433

	if (!CheckOwnership(v->owner))

   434

		return CMD_ERROR;

   435

   436

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

   437

		if (flags & DC_EXEC) {

   438

 			if (v->next_order&OF_UNLOAD)

   439

 				{ v->cur_order_index++; }

   440

			v->next_order = OT_DUMMY;

   441

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

   442

		}

   443

	} else {

   444

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

   445

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

   446

		// it surely doesn't have any hangars

   447

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

   448

					return CMD_ERROR;

   449

   450

		if (flags & DC_EXEC) {

   451

			v->next_order = OF_NON_STOP | OF_FULL_LOAD | OT_GOTO_DEPOT;

   452

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

   453

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

   454

		}

   455

	}

   456

   457

	return 0;

   458

}

   459

   460

// p1 = vehicle

   461

// p2 = new service int

   462

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

   463

{

   464

	Vehicle *v;

   465

   466

	v = &_vehicles[p1];

   467

   468

	if (!CheckOwnership(v->owner))

   469

		return CMD_ERROR;

   470

   471

	if (flags & DC_EXEC) {

   472

		v->service_interval = (uint16)p2;

   473

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

   474

	}

   475

   476

	return 0;

   477

}

   478

   479

// p1 = vehicle

   480

// p2 = new cargo type

   481

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

   482

{

   483

	Vehicle *v,*u;

   484

	int pass, mail;

   485

	int32 cost;

   486

   487

	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN);

   488

   489

	v = &_vehicles[p1];

   490

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

   491

		return CMD_ERROR;

   492

   493

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

   494

	if (p2 != 0) {

   495

		pass >>= 1;

   496

		if (p2 != 5)

   497

			pass >>= 1;

   498

	}

   499

	_aircraft_refit_capacity = pass;

   500

   501

	cost = 0;

   502

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

   503

		cost = _price.aircraft_base >> 7;

   504

	}

   505

   506

	if (flags & DC_EXEC) {

   507

		v->cargo_cap = pass;

   508

   509

		u = v->next;

   510

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

   511

		if (p2 != 0) {

   512

			mail = 0;

   513

		}

   514

		u->cargo_cap = mail;

   515

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

   516

		v->cargo_type = (byte)p2;

   517

		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);

   518

	}

   519

   520

	return cost;

   521

}

   522

   523

void HandleClickOnAircraft(Vehicle *v)

   524

{

   525

	ShowAircraftViewWindow(v);

   526

}

   527

   528

static void CheckIfAircraftNeedsService(Vehicle *v)