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

    22

static void AircraftNextAirportPos_and_Order(Vehicle *v);

    23

static byte GetAircraftFlyingAltitude(const Vehicle *v);

    24

    25

static const SpriteID _aircraft_sprite[] = {

    26

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

    27

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

    28

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

    29

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

    30

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

    31

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

    32

	0x0EBD, 0x0EC5

    33

};

    34

    35

int GetAircraftImage(Vehicle *v, byte direction)

    36

{

    37

	int spritenum = v->spritenum;

    38

    39

	if (is_custom_sprite(spritenum)) {

    40

		int sprite = GetCustomVehicleSprite(v, direction);

    41

    42

		if (sprite) return sprite;

    43

		spritenum = _engine_original_sprites[v->engine_type];

    44

	}

    45

	return direction + _aircraft_sprite[spritenum];

    46

}

    47

    48

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

    49

{

    50

	int spritenum = AircraftVehInfo(engine)->image_index;

    51

    52

	if (is_custom_sprite(spritenum)) {

    53

		int sprite = GetCustomVehicleIcon(engine, 6);

    54

    55

		if (sprite) {

    56

			DrawSprite(sprite | image_ormod, x, y);

    57

			return;

    58

		}

    59

		spritenum = _engine_original_sprites[engine];

    60

	}

    61

    62

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

    63

    64

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

    65

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

    66

}

    67

    68

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

    69

{

    70

	const AircraftVehicleInfo *avi = AircraftVehInfo(engine);

    71

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

    72

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

    73

	SetDParam(2, avi->passanger_capacity);

    74

	SetDParam(3, avi->mail_capacity);

    75

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

    76

    77

	DrawStringMultiCenter(x, y, STR_A02E_COST_MAX_SPEED_CAPACITY, maxw);

    78

}

    79

    80

/* Allocate many vehicles */

    81

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

    82

{

    83

	int i;

    84

	Vehicle *v;

    85

	bool success = true;

    86

    87

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

    88

		vl[i] = v = AllocateVehicle();

    89

		if (v == NULL) {

    90

			success = false;

    91

			break;

    92

		}

    93

		v->type = 1;

    94

	}

    95

    96

	while (--i >= 0) {

    97

		vl[i]->type = 0;

    98

	}

    99

   100

	return success;

   101

}

   102

   103

int32 EstimateAircraftCost(uint16 engine_type)

   104

{

   105

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

   106

}

   107

   108

   109

/* p1 = engine */

   110

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

   111

{

   112

	int32 value;

   113

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

   114

	byte unit_num;

   115

	uint tile = TILE_FROM_XY(x,y);

   116

	const AircraftVehicleInfo *avi = AircraftVehInfo(p1);

   117

	Engine *e;

   118

   119

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   120

   121

	value = EstimateAircraftCost(p1);

   122

   123

	if (flags & DC_QUERY_COST)

   124

		return value;

   125

   126

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

   127

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

   128

			_ptr_to_next_order >= endof(_order_array))

   129

					return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   130

   131

	unit_num = GetFreeUnitNumber(VEH_Aircraft);

   132

	if (unit_num > _patches.max_aircraft)

   133

		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   134

   135

	if (flags & DC_EXEC) {

   136

		v = vl[0];

   137

		u = vl[1];

   138

   139

		v->unitnumber = unit_num;

   140

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

   141

		v->direction = 3;

   142

   143

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

   144

   145

		v->tile = tile;

   146

//		u->tile = 0;

   147

   148

		x = GET_TILE_X(tile)*16 + 5;

   149

		y = GET_TILE_Y(tile)*16 + 3;

   150

   151

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

   152

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

   153

   154

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

   155

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

   156

   157

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

   158

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

   159

   160

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

   161

		v->z_height = 5;

   162

   163

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

   164

		u->z_height = 1;

   165

   166

		v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

   167

		u->vehstatus = VS_HIDDEN | VS_UNCLICKABLE | VS_DISASTER;

   168

   169

		v->spritenum = avi->image_index;

   170

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

   171

   172

		v->cargo_cap = avi->passanger_capacity;

   173

		u->cargo_cap = avi->mail_capacity;

   174

   175

		v->cargo_type = CT_PASSENGERS;

   176

		u->cargo_type = CT_MAIL;

   177

   178

		v->string_id = STR_SV_AIRCRAFT_NAME;

   179

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

   180

   181

//		v->load_unload_time_rem = 0;

   182

//		v->progress = 0;

   183

		v->last_station_visited = 0xFFFF;

   184

//		v->destination_coords = 0;

   185

   186

		v->max_speed = avi->max_speed;

   187

		v->acceleration = avi->acceleration;

   188

		v->engine_type = (byte)p1;

   189

   190

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

   191

		v->value = value;

   192

   193

		u->subtype = 4;

   194

   195

		e = &_engines[p1];

   196

		v->reliability = e->reliability;

   197

		v->reliability_spd_dec = e->reliability_spd_dec;

   198

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

   199

   200

		_new_aircraft_id = v->index;

   201

   202

		_ptr_to_next_order->type = OT_NOTHING;

   203

		_ptr_to_next_order->flags = 0;

   204

		v->schedule_ptr = _ptr_to_next_order++;

   205

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

   206

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

   207

		// On hold for NewAI

   208

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

   209

   210

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

   211

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

   212

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

   213

		*/

   214

		{

   215

			Station *st;

   216

			const AirportFTAClass *Airport;

   217

			const uint16 *cur_depot;

   218

			byte i = 0;

   219

			st = DEREF_STATION(_map2[tile]);

   220

			Airport = GetAirport(st->airport_type);

   221

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

   222

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

   223

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

   224

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

   225

					break;

   226

				}

   227

				i++;

   228

			}

   229

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

   230

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

   231

		}

   232

   233

		v->u.air.state = HANGAR;

   234

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

   235

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

   236

		v->next = u;

   237

   238

		v->service_interval = _patches.servint_aircraft;

   239

   240

		v->date_of_last_service = _date;

   241

		v->build_year = _cur_year;

   242

   243

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

   244

   245

		VehiclePositionChanged(v);

   246

		VehiclePositionChanged(u);

   247

   248

		// Aircraft with 3 vehicles?

   249

		if (v->subtype == 0) {

   250

			w = vl[2];

   251

   252

			u->next = w;

   253

   254

			w->type = VEH_Aircraft;

   255

			w->direction = 0;

   256

			w->owner = _current_player;

   257

			w->x_pos = v->x_pos;

   258

			w->y_pos = v->y_pos;

   259

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

   260

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

   261

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

   262

			w->z_height = 1;

   263

			w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE;

   264

			w->subtype = 6;

   265

			w->cur_image = 0xF3D;

   266

			VehiclePositionChanged(w);

   267

		}

   268

   269

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   270

		RebuildVehicleLists();

   271

		InvalidateWindow(WC_COMPANY, v->owner);

   272

	}

   273

   274

	return value;

   275

}

   276

   277

bool IsAircraftHangarTile(TileIndex tile)

   278

{

   279

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

   280

	// 0x20 - hangar large airport (32)

   281

	// 0x41 - hangar small airport (65)

   282

	return IS_TILETYPE(tile, MP_STATION) &&

   283

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

   284

}

   285

   286

static bool CheckStoppedInHangar(Vehicle *v)

   287

{

   288

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

   289

			!IsAircraftHangarTile(v->tile)) {

   290

		_error_message = STR_A01B_AIRCRAFT_MUST_BE_STOPPED;

   291

		return false;

   292

	}

   293

   294

	return true;

   295

}

   296

   297

   298

static void DoDeleteAircraft(Vehicle *v)

   299

{

   300

	DeleteWindowById(WC_VEHICLE_VIEW, v->index);

   301

	RebuildVehicleLists();

   302

	InvalidateWindow(WC_COMPANY, v->owner);

   303

	DeleteVehicleChain(v);

   304

}

   305

   306

// p1 = vehicle

   307

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

   308

{

   309

	Vehicle *v;

   310

   311

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   312

   313

	v = &_vehicles[p1];

   314

   315

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

   316

		return CMD_ERROR;

   317

   318

	if (flags & DC_EXEC) {

   319

		// Invalidate depot

   320

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   321

   322

		DoDeleteAircraft(v);

   323

   324

	}

   325

   326

	return -(int32)v->value;

   327

}

   328

   329

// p1 = vehicle

   330

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

   331

{

   332

	Vehicle *v;

   333

   334

	v = &_vehicles[p1];

   335

   336

	if (!CheckOwnership(v->owner))

   337

		return CMD_ERROR;

   338

   339

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

   340

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

   341

		return_cmd_error(STR_A017_AIRCRAFT_IS_IN_FLIGHT);

   342

	}

   343

   344

	if (flags & DC_EXEC) {

   345

		v->vehstatus ^= VS_STOPPED;

   346

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

   347

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   348

	}

   349

   350

	return 0;

   351

}

   352

   353

// p1 = vehicle

   354

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

   355

{

   356

	Vehicle *v;

   357

	Station *st;

   358

   359

	v = &_vehicles[p1];

   360

   361

	if (!CheckOwnership(v->owner))

   362

		return CMD_ERROR;

   363

   364

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

   365

		if (flags & DC_EXEC) {

   366

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

   367

			v->current_order.type = OT_DUMMY;

   368

			v->current_order.flags = 0;

   369

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

   370

		}

   371

	} else {

   372

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

   373

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

   374

		// it surely doesn't have any hangars

   375

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

   376

					return CMD_ERROR;

   377

   378

		if (flags & DC_EXEC) {

   379

			v->current_order.type = OT_GOTO_DEPOT;

   380

			v->current_order.flags = OF_NON_STOP | OF_FULL_LOAD;

   381

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

   382

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

   383

		}

   384

	}

   385

   386

	return 0;

   387

}

   388

   389

// p1 = vehicle

   390

// p2 = new service int

   391

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

   392

{

   393

	Vehicle *v;

   394

   395

	v = &_vehicles[p1];

   396

   397

	if (!CheckOwnership(v->owner))

   398

		return CMD_ERROR;

   399

   400

	if (flags & DC_EXEC) {

   401

		v->service_interval = (uint16)p2;

   402

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

   403

	}

   404

   405

	return 0;

   406

}

   407

   408

// p1 = vehicle

   409

// p2 = new cargo type(0xFF)

   410

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

   411

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

   412

{

   413

	Vehicle *v,*u;

   414

	int pass, mail;

   415

	int32 cost;

   416

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

   417

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

   418

   419

	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN);

   420

   421

	v = &_vehicles[p1];

   422

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

   423

		return CMD_ERROR;

   424

   425

	pass = AircraftVehInfo(v->engine_type)->passanger_capacity;

   426

	if (new_cargo_type != CT_PASSENGERS) {

   427

		pass >>= 1;

   428

		if (new_cargo_type != CT_GOODS)

   429

			pass >>= 1;

   430

	}

   431

	_aircraft_refit_capacity = pass;

   432

   433

	cost = 0;

   434

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

   435

		cost = _price.aircraft_base >> 7;

   436

	}

   437

   438

	if (flags & DC_EXEC) {

   439

		v->cargo_cap = pass;

   440

   441

		u = v->next;

   442

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

   443

		if (new_cargo_type != CT_PASSENGERS) {

   444

			mail = 0;

   445

		}

   446

		u->cargo_cap = mail;

   447

		//autorefitted planes wants to keep the cargo

   448

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

   449

		if (!(SkipStoppedInHangerCheck))

   450

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

   451

		v->cargo_type = new_cargo_type;

   452

		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);

   453

	}

   454

   455

	return cost;

   456

}

   457

   458

void HandleClickOnAircraft(Vehicle *v)

   459

{

   460

	ShowAircraftViewWindow(v);

   461

}

   462

   463

static void CheckIfAircraftNeedsService(Vehicle *v)

   464

{

   465

	Station *st;

   466

   467

	if (_patches.servint_aircraft == 0)

   468

		return;

   469

   470

	if (!VehicleNeedsService(v))

   471

		return;

   472

   473

	if (v->vehstatus & VS_STOPPED)

   474

		return;

   475

   476

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

   477

			v->current_order.flags & OF_FULL_LOAD)

   478

		return;

   479

   480

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

   481

 		return;

   482

   483

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

   484

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

   485

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

   486

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

   487

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

   488

		v->current_order.type = OT_GOTO_DEPOT;

   489

		v->current_order.flags = OF_NON_STOP;

   490

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

   491

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

   492

		v->current_order.type = OT_DUMMY;

   493

		v->current_order.flags = 0;

   494

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

   495

	}

   496

}

   497

   498

void OnNewDay_Aircraft(Vehicle *v)

   499

{

   500

	int32 cost;

   501

   502

	if (v->subtype > 2)

   503

		return;

   504

   505

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

   506

		DecreaseVehicleValue(v);

   507

   508

	CheckOrders(v);

   509

   510

	CheckVehicleBreakdown(v);

   511

	AgeVehicle(v);

   512

	CheckIfAircraftNeedsService(v);

   513

   514

	if (v->vehstatus & VS_STOPPED)

   515

		return;

   516

   517

	cost = AircraftVehInfo(v->engine_type)->running_cost * _price.aircraft_running / 364;