1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     5

#include "tile.h"

     6

#include "vehicle.h"

     7

#include "engine.h"

     8

#include "command.h"

     9

#include "station.h"

    10

#include "news.h"

    11

#include "gfx.h"

    12

#include "sound.h"

    13

#include "player.h"

    14

#include "airport.h"

    15

    16

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

    17

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

    18

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

    19

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

    20

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

    21

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

    22

static void CrashAirplane(Vehicle *v);

    23

    24

static void AircraftNextAirportPos_and_Order(Vehicle *v);

    25

static byte GetAircraftFlyingAltitude(const Vehicle *v);

    26

    27

static const SpriteID _aircraft_sprite[] = {

    28

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

    29

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

    30

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

    31

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

    32

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

    33

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

    34

	0x0EBD, 0x0EC5

    35

};

    36

    37

// use this to find the nearest hangar to v

    38

// bit 16 is set in the return value if the player do not have any airports with a hangar (like helipads only)

    39

static uint32 FindNearestHangar(Vehicle *v)

    40

{

    41

	Station *st;

    42

	uint temp_distance, distance = 0xFFFF;

    43

	uint16 index_to_target = 0;

    44

    45

	FOR_ALL_STATIONS(st) {

    46

		if (st->owner == v->owner && st->facilities & FACIL_AIRPORT) {

    47

			if (GetAirport(st->airport_type)->terminals != NULL) {

    48

				// don't crash the planes if we know they can't land at the airport

    49

				if (HASBIT(v->subtype,1) && st->airport_type == AT_SMALL && !_cheats.no_jetcrash.value) continue;

    50

    51

				temp_distance = GetTileDistAdv(v->tile, st->airport_tile);

    52

				if (temp_distance < distance) {

    53

					distance = temp_distance;

    54

					index_to_target = st->index;

    55

				}

    56

			}

    57

		}

    58

	}

    59

	if (distance == 65000)

    60

		SETBIT(index_to_target, 16);

    61

	return index_to_target;

    62

}

    63

    64

// returns true if vehicle v have an airport in the schedule, that has a hangar

    65

static bool HaveHangarInOrderList(Vehicle *v)

    66

{

    67

	const Order *order;

    68

    69

	FOR_VEHICLE_ORDERS(v, order) {

    70

		const Station *st = GetStation(order->station);

    71

		if (st->owner == v->owner && st->facilities & FACIL_AIRPORT) {

    72

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

    73

			// it surely doesn't have any hangars

    74

			if (GetAirport(st->airport_type)->terminals != NULL)

    75

				return true;

    76

		}

    77

	}

    78

    79

	return false;

    80

}

    81

    82

int GetAircraftImage(Vehicle *v, byte direction)

    83

{

    84

	int spritenum = v->spritenum;

    85

    86

	if (is_custom_sprite(spritenum)) {

    87

		int sprite = GetCustomVehicleSprite(v, direction);

    88

    89

		if (sprite) return sprite;

    90

		spritenum = _engine_original_sprites[v->engine_type];

    91

	}

    92

	return direction + _aircraft_sprite[spritenum];

    93

}

    94

    95

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

    96

{

    97

	int spritenum = AircraftVehInfo(engine)->image_index;

    98

	int sprite = (6 + _aircraft_sprite[spritenum]);

    99

   100

	if (is_custom_sprite(spritenum)) {

   101

		sprite = GetCustomVehicleIcon(engine, 6);

   102

		if (!sprite)

   103

			sprite = _engine_original_sprites[engine];

   104

	}

   105

   106

	DrawSprite(sprite | image_ormod, x, y);

   107

   108

	if ((AircraftVehInfo(engine)->subtype & 1) == 0) {

   109

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

   110

	}

   111

}

   112

   113

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

   114

{

   115

	const AircraftVehicleInfo *avi = AircraftVehInfo(engine);

   116

	SetDParam(0, ((_price.aircraft_base >> 3) * avi->base_cost) >> 5);

   117

	SetDParam(1, avi->max_speed << 3);

   118

	SetDParam(2, avi->passenger_capacity);

   119

	SetDParam(3, avi->mail_capacity);

   120

	SetDParam(4, avi->running_cost * _price.aircraft_running >> 8);

   121

   122

	DrawStringMultiCenter(x, y, STR_A02E_COST_MAX_SPEED_CAPACITY, maxw);

   123

}

   124

   125

/* Allocate many vehicles */

   126

static bool AllocateVehicles(Vehicle **vl, int num)

   127

{

   128

	int i;

   129

	Vehicle *v;

   130

	bool success = true;

   131

   132

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

   133

		vl[i] = v = AllocateVehicle();

   134

		if (v == NULL) {

   135

			success = false;

   136

			break;

   137

		}

   138

		v->type = 1;

   139

	}

   140

   141

	while (--i >= 0) {

   142

		vl[i]->type = 0;

   143

	}

   144

   145

	return success;

   146

}

   147

   148

int32 EstimateAircraftCost(uint16 engine_type)

   149

{

   150

	return AircraftVehInfo(engine_type)->base_cost * (_price.aircraft_base>>3)>>5;

   151

}

   152

   153

   154

/* p1 = engine */

   155

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

   156

{

   157

	int32 value;

   158

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

   159

	byte unit_num;

   160

	uint tile = TILE_FROM_XY(x,y);

   161

	const AircraftVehicleInfo *avi = AircraftVehInfo(p1);

   162

	Engine *e;

   163

   164

	if (!IsEngineBuildable(p1, VEH_Aircraft)) return CMD_ERROR;

   165

   166

	// Workaround: TODO: make AI players try to build planes in a hangar instead of just an airport tile.

   167

	if (!IsAircraftHangarTile((TileIndex)tile) && IS_HUMAN_PLAYER(_current_player)) return CMD_ERROR;

   168

   169

	if (_map_owner[tile] != _current_player) return CMD_ERROR;

   170

   171

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   172

   173

	value = EstimateAircraftCost(p1);

   174

   175

	if (flags & DC_QUERY_COST)

   176

		return value;

   177

   178

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

   179

	if (!AllocateVehicles(vl, (avi->subtype & 1) == 0 ? 3 : 2) ||

   180

				IsOrderPoolFull())

   181

					return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   182

   183

	unit_num = GetFreeUnitNumber(VEH_Aircraft);

   184

	if (unit_num > _patches.max_aircraft)

   185

		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   186

   187

	if (flags & DC_EXEC) {

   188

		v = vl[0];

   189

		u = vl[1];

   190

   191

		v->unitnumber = unit_num;

   192

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

   193

		v->direction = 3;

   194

   195

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

   196

   197

		v->tile = tile;

   198

//		u->tile = 0;

   199

   200

		x = TileX(tile) * 16 + 5;

   201

		y = TileY(tile) * 16 + 3;

   202

   203

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

   204

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

   205

   206

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

   207

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

   208

   209

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

   210

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

   211

   212

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

   213

		v->z_height = 5;

   214

   215

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

   216

		u->z_height = 1;

   217

   218

		v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

   219

		u->vehstatus = VS_HIDDEN | VS_UNCLICKABLE | VS_DISASTER;

   220

   221

		v->spritenum = avi->image_index;

   222

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

   223

   224

		v->cargo_cap = avi->passenger_capacity;

   225

		u->cargo_cap = avi->mail_capacity;

   226

   227

		v->cargo_type = CT_PASSENGERS;

   228

		u->cargo_type = CT_MAIL;

   229

   230

		v->string_id = STR_SV_AIRCRAFT_NAME;

   231

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

   232

   233

//		v->load_unload_time_rem = 0;

   234

//		v->progress = 0;

   235

		v->last_station_visited = 0xFFFF;

   236

//		v->destination_coords = 0;

   237

   238

		v->max_speed = avi->max_speed;

   239

		v->acceleration = avi->acceleration;

   240

		v->engine_type = (byte)p1;

   241

   242

		v->subtype = (avi->subtype & 1) == 0 ? 0 : 2;

   243

		v->value = value;

   244

   245

		u->subtype = 4;

   246

   247

		e = &_engines[p1];

   248

		v->reliability = e->reliability;

   249

		v->reliability_spd_dec = e->reliability_spd_dec;

   250

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

   251

   252

		_new_aircraft_id = v->index;

   253

   254

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

   255

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

   256

		// On hold for NewAI

   257

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

   258

   259

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

   260

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

   261

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

   262

		*/

   263

		{

   264

			Station *st;

   265

			const AirportFTAClass *Airport;

   266

			const TileIndexDiffC *cur_depot;

   267

			byte i = 0;

   268

			st = GetStation(_map2[tile]);

   269

			Airport = GetAirport(st->airport_type);

   270

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

   271

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

   272

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

   273

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

   274

					break;

   275

				}

   276

				i++;

   277

			}

   278

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

   279

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

   280

		}

   281

   282

		v->u.air.state = HANGAR;

   283

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

   284

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

   285

		v->next = u;

   286

   287

		v->service_interval = _patches.servint_aircraft;

   288

   289

		v->date_of_last_service = _date;

   290

		v->build_year = _cur_year;

   291

   292

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

   293

   294

		VehiclePositionChanged(v);

   295

		VehiclePositionChanged(u);

   296

   297

		// Aircraft with 3 vehicles?

   298

		if (v->subtype == 0) {

   299

			w = vl[2];

   300

   301

			u->next = w;

   302

   303

			w->type = VEH_Aircraft;

   304

			w->direction = 0;

   305

			w->owner = _current_player;

   306

			w->x_pos = v->x_pos;

   307

			w->y_pos = v->y_pos;

   308

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

   309

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

   310

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

   311

			w->z_height = 1;

   312

			w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE;

   313

			w->subtype = 6;

   314

			w->cur_image = 0xF3D;

   315

			VehiclePositionChanged(w);

   316

		}

   317

   318

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   319

		RebuildVehicleLists();

   320

		InvalidateWindow(WC_COMPANY, v->owner);

   321

	}

   322

   323

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_Aircraft); //updates the replace Aircraft window

   324

   325

	return value;

   326

}

   327

   328

bool IsAircraftHangarTile(TileIndex tile)

   329

{

   330

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

   331

	// 0x20 - hangar large airport (32)

   332

	// 0x41 - hangar small airport (65)

   333

	return IsTileType(tile, MP_STATION) &&

   334

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

   335

}

   336

   337

static bool CheckStoppedInHangar(Vehicle *v)

   338

{

   339

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

   340

			!IsAircraftHangarTile(v->tile)) {

   341

		_error_message = STR_A01B_AIRCRAFT_MUST_BE_STOPPED;

   342

		return false;

   343

	}

   344

   345

	return true;

   346

}

   347

   348

   349

static void DoDeleteAircraft(Vehicle *v)

   350

{

   351

	DeleteWindowById(WC_VEHICLE_VIEW, v->index);

   352

	RebuildVehicleLists();

   353

	InvalidateWindow(WC_COMPANY, v->owner);

   354

	DeleteVehicleChain(v);

   355

	InvalidateWindowClasses(WC_AIRCRAFT_LIST);

   356

}

   357

   358

// p1 = vehicle

   359

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

   360

{

   361

	Vehicle *v;

   362

   364

   365

	v = GetVehicle(p1);

   366

   367

	if (v->type != VEH_Aircraft || !CheckOwnership(v->owner) || !CheckStoppedInHangar(v))

   368

		return CMD_ERROR;

   369

   372

	if (flags & DC_EXEC) {

   373

		// Invalidate depot

   374

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   375

   376

		DoDeleteAircraft(v);

   377

   378

	}

   379

   380

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_Aircraft); // updates the replace Aircraft window

   381

   382

	return -(int32)v->value;

   383

}

   384

   385

// p1 = vehicle

   386

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

   387

{

   388

	Vehicle *v;

   389

   392

	v = GetVehicle(p1);

   393

   395

		return CMD_ERROR;

   396

   397

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

   398

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

   399

		return_cmd_error(STR_A017_AIRCRAFT_IS_IN_FLIGHT);

   400

	}

   401

   402

	if (flags & DC_EXEC) {

   403

		v->vehstatus ^= VS_STOPPED;

   404

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

   405

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   406

		InvalidateWindowClasses(WC_AIRCRAFT_LIST);

   407

	}

   408

   409

	return 0;

   410

}

   411

   412

/*  Send an aircraft to the hangar in the next station

   413

	p1 = index of the aircraft

   414

	p2 = bit 0..15 = index of station with hangar to use (only used if bit 17 is set)

   415

		 bit 16 = set v->set_for_replacement & do not stop in hangar

   416

		 bit 17 = goto the hangar in airport given in bit 0..15 instead of next stop

   417

		 bit 18 = clear v->set_for_replacement */

   418

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

   419

{

   420

	Vehicle *v;

   421

	Station *st;

   422

	uint16 next_airport_index;

   423

   426

	v = GetVehicle(p1);

   427

   429

		return CMD_ERROR;

   430

   431

	if (HASBIT(p2, 16)) v->set_for_replacement = true; //now all clients knows that the vehicle wants to be replaced

   432

   433

	if (HASBIT(p2, 18)) {

   434

		v->set_for_replacement = false;

   435

		return CMD_ERROR; // no need to send aircraft to a depot. We just told that it don't have to anymore

   436

	}

   437

   438

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

   439

		if (flags & DC_EXEC) {

   440

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

   441

			v->current_order.type = OT_DUMMY;

   442

			v->current_order.flags = 0;

   443

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

   444

		}

   445

	} else {

   446

		next_airport_index = (HASBIT(p2, 17)) ? (int16)p2 : v->u.air.targetairport;

   447

		st = GetStation(next_airport_index);

   448

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

   449

		// it surely doesn't have any hangars

   450

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

   451

					return CMD_ERROR;

   452

   453

		if (flags & DC_EXEC) {

   454

			v->current_order.type = OT_GOTO_DEPOT;

   455

			v->current_order.flags = v->set_for_replacement ? 0 : OF_NON_STOP | OF_FULL_LOAD;

   456

			v->current_order.station = next_airport_index;

   457

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

   458

			if (HASBIT(p2, 17)) {

   459

				AircraftNextAirportPos_and_Order(v);

   460

				v->u.air.targetairport = next_airport_index;

   461

			}

   462

		}

   463

	}

   464

   465

	return 0;

   466

}

   467

   468

// p1 = vehicle

   469

// p2 = new service int

   470

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

   471

{

   472

	Vehicle *v;

   473

   476

	v = GetVehicle(p1);

   477

   479

		return CMD_ERROR;

   480

   481

	if (flags & DC_EXEC) {

   482

		v->service_interval = (uint16)p2;

   483

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

   484

	}

   485

   486

	return 0;

   487

}

   488

   489

// p1 = vehicle

   490

// p2 = new cargo type(0xFF)

   491

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

   492

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

   493

{

   494

	Vehicle *v,*u;

   495

	int pass, mail;

   496

	int32 cost;

   497

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

   498

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

   499

	AircraftVehicleInfo *avi;

   500

   502

   503

	v = GetVehicle(p1);

   507

	avi = AircraftVehInfo(v->engine_type);