1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     5

#include "vehicle.h"

     6

#include "engine.h"

     7

#include "command.h"

     8

#include "station.h"

     9

#include "news.h"

    10

#include "gfx.h"

    11

#include "sound.h"

    12

#include "player.h"

    13

#include "airport.h"

    14

    15

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

    16

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

    17

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

    18

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

    19

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

    20

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

    21

static void CrashAirplane(Vehicle *v);

    22

    23

static void AircraftNextAirportPos_and_Order(Vehicle *v);

    24

static byte GetAircraftFlyingAltitude(const Vehicle *v);

    25

    26

static const SpriteID _aircraft_sprite[] = {

    27

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

    28

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

    29

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

    30

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

    31

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

    32

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

    33

	0x0EBD, 0x0EC5

    34

};

    35

    36

int GetAircraftImage(Vehicle *v, byte direction)

    37

{

    38

	int spritenum = v->spritenum;

    39

    40

	if (is_custom_sprite(spritenum)) {

    41

		int sprite = GetCustomVehicleSprite(v, direction);

    42

    43

		if (sprite) return sprite;

    44

		spritenum = _engine_original_sprites[v->engine_type];

    45

	}

    46

	return direction + _aircraft_sprite[spritenum];

    47

}

    48

    49

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

    50

{

    51

	int spritenum = AircraftVehInfo(engine)->image_index;

    52

    53

	if (is_custom_sprite(spritenum)) {

    54

		int sprite = GetCustomVehicleIcon(engine, 6);

    55

    56

		if (sprite) {

    57

			DrawSprite(sprite | image_ormod, x, y);

    58

			return;

    59

		}

    60

		spritenum = _engine_original_sprites[engine];

    61

	}

    62

    63

	DrawSprite((6 + _aircraft_sprite[spritenum]) | image_ormod, x, y);

    64

    65

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

    66

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

    67

}

    68

    69

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

    70

{

    71

	const AircraftVehicleInfo *avi = AircraftVehInfo(engine);

    72

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

    73

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

    75

	SetDParam(3, avi->mail_capacity);

    76

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

    77

    78

	DrawStringMultiCenter(x, y, STR_A02E_COST_MAX_SPEED_CAPACITY, maxw);

    79

}

    80

    81

/* Allocate many vehicles */

    82

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

    83

{

    84

	int i;

    85

	Vehicle *v;

    86

	bool success = true;

    87

    88

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

    89

		vl[i] = v = AllocateVehicle();

    90

		if (v == NULL) {

    91

			success = false;

    92

			break;

    93

		}

    94

		v->type = 1;

    95

	}

    96

    97

	while (--i >= 0) {

    98

		vl[i]->type = 0;

    99

	}

   100

   101

	return success;

   102

}

   103

   104

int32 EstimateAircraftCost(uint16 engine_type)

   105

{

   106

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

   107

}

   108

   109

   110

/* p1 = engine */

   111

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

   112

{

   113

	int32 value;

   114

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

   115

	byte unit_num;

   116

	uint tile = TILE_FROM_XY(x,y);

   117

	const AircraftVehicleInfo *avi = AircraftVehInfo(p1);

   118

	Engine *e;

   119

   120

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   121

   122

	value = EstimateAircraftCost(p1);

   123

   124

	if (flags & DC_QUERY_COST)

   125

		return value;

   126

   127

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

   128

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

   129

			_ptr_to_next_order >= endof(_order_array))

   130

					return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   131

   132

	unit_num = GetFreeUnitNumber(VEH_Aircraft);

   133

	if (unit_num > _patches.max_aircraft)

   134

		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   135

   136

	if (flags & DC_EXEC) {

   137

		v = vl[0];

   138

		u = vl[1];

   139

   140

		v->unitnumber = unit_num;

   141

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

   142

		v->direction = 3;

   143

   144

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

   145

   146

		v->tile = tile;

   147

//		u->tile = 0;

   148

   149

		x = GET_TILE_X(tile)*16 + 5;

   150

		y = GET_TILE_Y(tile)*16 + 3;

   151

   152

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

   153

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

   154

   155

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

   156

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

   157

   158

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

   159

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

   160

   161

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

   162

		v->z_height = 5;

   163

   164

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

   165

		u->z_height = 1;

   166

   167

		v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

   168

		u->vehstatus = VS_HIDDEN | VS_UNCLICKABLE | VS_DISASTER;

   169

   170

		v->spritenum = avi->image_index;

   171

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

   172

   174

		u->cargo_cap = avi->mail_capacity;

   175

   176

		v->cargo_type = CT_PASSENGERS;

   177

		u->cargo_type = CT_MAIL;

   178

   179

		v->string_id = STR_SV_AIRCRAFT_NAME;

   180

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

   181

   182

//		v->load_unload_time_rem = 0;

   183

//		v->progress = 0;

   184

		v->last_station_visited = 0xFFFF;

   185

//		v->destination_coords = 0;

   186

   187

		v->max_speed = avi->max_speed;

   188

		v->acceleration = avi->acceleration;

   189

		v->engine_type = (byte)p1;

   190

   191

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

   192

		v->value = value;

   193

   194

		u->subtype = 4;

   195

   196

		e = &_engines[p1];

   197

		v->reliability = e->reliability;

   198

		v->reliability_spd_dec = e->reliability_spd_dec;

   199

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

   200

   201

		_new_aircraft_id = v->index;

   202

   203

		_ptr_to_next_order->type = OT_NOTHING;

   204

		_ptr_to_next_order->flags = 0;

   205

		v->schedule_ptr = _ptr_to_next_order++;

   206

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

   207

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

   208

		// On hold for NewAI

   209

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

   210

   211

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

   212

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

   213

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

   214

		*/

   215

		{

   216

			Station *st;

   217

			const AirportFTAClass *Airport;

   218

			const TileIndexDiffC *cur_depot;

   219

			byte i = 0;

   220

			st = GetStation(_map2[tile]);

   221

			Airport = GetAirport(st->airport_type);

   222

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

   223

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

   224

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

   225

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

   226

					break;

   227

				}

   228

				i++;

   229

			}

   230

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

   231

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

   232

		}

   233

   234

		v->u.air.state = HANGAR;

   235

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

   236

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

   237

		v->next = u;

   238

   239

		v->service_interval = _patches.servint_aircraft;

   240

   241

		v->date_of_last_service = _date;

   242

		v->build_year = _cur_year;

   243

   244

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

   245

   246

		VehiclePositionChanged(v);

   247

		VehiclePositionChanged(u);

   248

   249

		// Aircraft with 3 vehicles?

   250

		if (v->subtype == 0) {

   251

			w = vl[2];

   252

   253

			u->next = w;

   254

   255

			w->type = VEH_Aircraft;

   256

			w->direction = 0;

   257

			w->owner = _current_player;

   258

			w->x_pos = v->x_pos;

   259

			w->y_pos = v->y_pos;

   260

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

   261

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

   262

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

   263

			w->z_height = 1;

   264

			w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE;

   265

			w->subtype = 6;

   266

			w->cur_image = 0xF3D;

   267

			VehiclePositionChanged(w);

   268

		}

   269

   270

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   271

		RebuildVehicleLists();

   272

		InvalidateWindow(WC_COMPANY, v->owner);

   273

	}

   274

   275

	return value;

   276

}

   277

   278

bool IsAircraftHangarTile(TileIndex tile)

   279

{

   280

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

   281

	// 0x20 - hangar large airport (32)

   282

	// 0x41 - hangar small airport (65)

   283

	return IS_TILETYPE(tile, MP_STATION) &&

   284

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

   285

}

   286

   287

static bool CheckStoppedInHangar(Vehicle *v)

   288

{

   289

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

   290

			!IsAircraftHangarTile(v->tile)) {

   291

		_error_message = STR_A01B_AIRCRAFT_MUST_BE_STOPPED;

   292

		return false;

   293

	}

   294

   295

	return true;

   296

}

   297

   298

   299

static void DoDeleteAircraft(Vehicle *v)

   300

{

   301

	DeleteWindowById(WC_VEHICLE_VIEW, v->index);

   302

	RebuildVehicleLists();

   303

	InvalidateWindow(WC_COMPANY, v->owner);

   304

	DeleteVehicleChain(v);

   305

}

   306

   307

// p1 = vehicle

   308

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

   309

{

   310

	Vehicle *v;

   311

   312

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   313

   314

	v = GetVehicle(p1);

   315

   316

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

   317

		return CMD_ERROR;

   318

   319

	if (flags & DC_EXEC) {

   320

		// Invalidate depot

   321

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   322

   323

		DoDeleteAircraft(v);

   324

   325

	}

   326

   327

	return -(int32)v->value;

   328

}

   329

   330

// p1 = vehicle

   331

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

   332

{

   333

	Vehicle *v;

   334

   335

	v = GetVehicle(p1);

   336

   337

	if (!CheckOwnership(v->owner))

   338

		return CMD_ERROR;

   339

   340

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

   341

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

   342

		return_cmd_error(STR_A017_AIRCRAFT_IS_IN_FLIGHT);

   343

	}

   344

   345

	if (flags & DC_EXEC) {

   346

		v->vehstatus ^= VS_STOPPED;

   347

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

   348

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   349

	}

   350

   351

	return 0;

   352

}

   353

   354

// p1 = vehicle

   355

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

   356

{

   357

	Vehicle *v;

   358

	Station *st;

   359

   360

	v = GetVehicle(p1);

   361

   362

	if (!CheckOwnership(v->owner))

   363

		return CMD_ERROR;

   364

   365

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

   366

		if (flags & DC_EXEC) {

   367

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

   368

			v->current_order.type = OT_DUMMY;

   369

			v->current_order.flags = 0;

   370

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

   371

		}

   372

	} else {

   373

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

   374

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

   375

		// it surely doesn't have any hangars

   376

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

   377

					return CMD_ERROR;

   378

   379

		if (flags & DC_EXEC) {

   380

			v->current_order.type = OT_GOTO_DEPOT;

   381

			v->current_order.flags = OF_NON_STOP | OF_FULL_LOAD;

   382

			v->current_order.station = v->u.air.targetairport;

   383

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

   384

		}

   385

	}

   386

   387

	return 0;

   388

}

   389

   390

// p1 = vehicle

   391

// p2 = new service int

   392

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

   393

{

   394

	Vehicle *v;

   395

   396

	v = GetVehicle(p1);

   397

   398

	if (!CheckOwnership(v->owner))

   399

		return CMD_ERROR;

   400

   401

	if (flags & DC_EXEC) {

   402

		v->service_interval = (uint16)p2;

   403

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

   404

	}

   405

   406

	return 0;

   407

}

   408

   409

// p1 = vehicle

   410

// p2 = new cargo type(0xFF)

   411

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

   412

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

   413

{

   414

	Vehicle *v,*u;

   415

	int pass, mail;

   416

	int32 cost;

   417

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

   418

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

   419

   420

	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN);

   421

   422

	v = GetVehicle(p1);

   423

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

   424

		return CMD_ERROR;

   425

   427

	if (new_cargo_type != CT_PASSENGERS) {

   428

		pass >>= 1;

   429

		if (new_cargo_type != CT_GOODS)

   430

			pass >>= 1;

   431

	}

   432

	_aircraft_refit_capacity = pass;

   433

   434

	cost = 0;

   435

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

   436

		cost = _price.aircraft_base >> 7;

   437

	}

   438

   439

	if (flags & DC_EXEC) {

   440

		v->cargo_cap = pass;

   441

   442

		u = v->next;

   443

		mail = AircraftVehInfo(v->engine_type)->mail_capacity;

   444

		if (new_cargo_type != CT_PASSENGERS) {

   445

			mail = 0;

   446

		}

   447

		u->cargo_cap = mail;

   448

		//autorefitted planes wants to keep the cargo

   449

		//it will be checked if the cargo is valid in CmdReplaceVehicle

   450

		if (!(SkipStoppedInHangerCheck))

   451

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

   452

		v->cargo_type = new_cargo_type;

   453

		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);

   454

	}

   455

   456

	return cost;

   457

}

   458

   459

void HandleClickOnAircraft(Vehicle *v)

   460

{

   461

	ShowAircraftViewWindow(v);

   462

}

   463

   464

static void CheckIfAircraftNeedsService(Vehicle *v)

   465

{

   466

	Station *st;

   467

   468

	if (_patches.servint_aircraft == 0)

   469

		return;

   470

   471

	if (!VehicleNeedsService(v))

   472

		return;

   473

   474

	if (v->vehstatus & VS_STOPPED)

   475

		return;

   476

   477

	if (v->current_order.type == OT_GOTO_DEPOT &&

   478

			v->current_order.flags & OF_FULL_LOAD)

   479

		return;

   480

   481

 	if (_patches.gotodepot && ScheduleHasDepotOrders(v->schedule_ptr))

   482

 		return;

   483

   484

	st = GetStation(v->current_order.station);

   485

	// only goto depot if the target airport has terminals (eg. it is airport)

   486

	if (st->xy != 0 && st->airport_tile != 0 && GetAirport(st->airport_type)->nofterminals != 0) {

   487

//		printf("targetairport = %d, st->index = %d\n", v->u.air.targetairport, st->index);

   488

//		v->u.air.targetairport = st->index;

   489

		v->current_order.type = OT_GOTO_DEPOT;

   490

		v->current_order.flags = OF_NON_STOP;

   491

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

   492

	} else if (v->current_order.type == OT_GOTO_DEPOT) {

   493

		v->current_order.type = OT_DUMMY;

   494

		v->current_order.flags = 0;

   495

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

   496

	}

   497

}

   498

   499

void OnNewDay_Aircraft(Vehicle *v)

   500

{

   501

	int32 cost;

   502

   503

	if (v->subtype > 2)

   504

		return;

   505

   506

	if ((++v->day_counter & 7) == 0)

   507

		DecreaseVehicleValue(v);

   508

   509

	CheckOrders(v);

   510

   511

	CheckVehicleBreakdown(v);

   512

	AgeVehicle(v);

   513

	CheckIfAircraftNeedsService(v);

   514

   515

	if (v->vehstatus & VS_STOPPED)