1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "vehicle.h"

     5

#include "engine.h"

     6

#include "command.h"

     7

#include "station.h"

     8

#include "news.h"

     9

#include "gfx.h"

    10

#include "sound.h"

    11

#include "player.h"

    12

#include "airport.h"

    13

    14

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

    15

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

    16

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

    17

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

    18

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

    19

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

    20

    21

static void AircraftNextAirportPos_and_Order(Vehicle *v);

    22

static byte GetAircraftFlyingAltitude(const Vehicle *v);

    23

    24

static const SpriteID _aircraft_sprite[] = {

    25

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

    26

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

    27

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

    28

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

    29

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

    30

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

    31

	0x0EBD, 0x0EC5

    32

};

    33

    34

int GetAircraftImage(Vehicle *v, byte direction)

    35

{

    36

	int spritenum = v->spritenum;

    37

    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

	return direction + _aircraft_sprite[spritenum];

    45

}

    46

    47

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

    48

{

    49

	int spritenum = AircraftVehInfo(engine)->image_index;

    50

    51

	if (is_custom_sprite(spritenum)) {

    52

		int sprite = GetCustomVehicleIcon(engine, 6);

    53

    54

		if (sprite) {

    55

			DrawSprite(sprite | image_ormod, x, y);

    56

			return;

    57

		}

    58

		spritenum = _engine_original_sprites[engine];

    59

	}

    60

    61

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

    62

    63

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

    64

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

    65

}

    66

    67

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

    68

{

    69

	const AircraftVehicleInfo *avi = AircraftVehInfo(engine);

    70

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

    71

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

    72

	SetDParam(2, avi->passanger_capacity);

    73

	SetDParam(3, avi->mail_capacity);

    74

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

    75

    76

	DrawStringMultiCenter(x, y, STR_A02E_COST_MAX_SPEED_CAPACITY, maxw);

    77

}

    78

    79

/* Allocate many vehicles */

    80

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

    81

{

    82

	int i;

    83

	Vehicle *v;

    84

	bool success = true;

    85

    86

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

    87

		vl[i] = v = AllocateVehicle();

    88

		if (v == NULL) {

    89

			success = false;

    90

			break;

    91

		}

    92

		v->type = 1;

    93

	}

    94

    95

	while (--i >= 0) {

    96

		vl[i]->type = 0;

    97

	}

    98

    99

	return success;

   100

}

   101

   102

static int32 EstimateAircraftCost(uint16 engine_type)

   103

{

   104

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

   105

}

   106

   107

   108

/* p1 = engine */

   109

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

   110

{

   111

	int32 value;

   112

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

   113

	byte unit_num;

   114

	uint tile = TILE_FROM_XY(x,y);

   115

	const AircraftVehicleInfo *avi = AircraftVehInfo(p1);

   116

	Engine *e;

   117

   118

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   119

   120

	value = EstimateAircraftCost(p1);

   121

   122

	if (flags & DC_QUERY_COST)

   123

		return value;

   124

   125

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

   126

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

   127

			_ptr_to_next_order >= endof(_order_array))

   128

					return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   129

   130

	unit_num = GetFreeUnitNumber(VEH_Aircraft);

   131

	if (unit_num > _patches.max_aircraft)

   132

		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   133

   134

	if (flags & DC_EXEC) {

   135

		v = vl[0];

   136

		u = vl[1];

   137

   138

		v->unitnumber = unit_num;

   139

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

   140

		v->direction = 3;

   141

   142

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

   143

   144

		v->tile = tile;

   145

//		u->tile = 0;

   146

   147

		x = GET_TILE_X(tile)*16 + 5;

   148

		y = GET_TILE_Y(tile)*16 + 3;

   149

   150

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

   151

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

   152

   153

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

   154

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

   155

   156

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

   157

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

   158

   159

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

   160

		v->z_height = 5;

   161

   162

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

   163

		u->z_height = 1;

   164

   165

		v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

   166

		u->vehstatus = VS_HIDDEN | VS_UNCLICKABLE | VS_DISASTER;

   167

   168

		v->spritenum = avi->image_index;

   169

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

   170

   171

		v->cargo_cap = avi->passanger_capacity;

   172

		u->cargo_cap = avi->mail_capacity;

   173

   174

		v->cargo_type = CT_PASSENGERS;

   175

		u->cargo_type = CT_MAIL;

   176

   177

		v->string_id = STR_SV_AIRCRAFT_NAME;

   178

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

   179

   180

//		v->load_unload_time_rem = 0;

   181

//		v->progress = 0;

   182

		v->last_station_visited = 0xFF;

   183

//		v->destination_coords = 0;

   184

   185

		v->max_speed = avi->max_speed;

   186

		v->acceleration = avi->acceleration;

   187

		v->engine_type = (byte)p1;

   188

   189

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

   190

		v->value = value;

   191

   192

		u->subtype = 4;

   193

   194

		e = &_engines[p1];

   195

		v->reliability = e->reliability;

   196

		v->reliability_spd_dec = e->reliability_spd_dec;

   197

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

   198

   199

		_new_aircraft_id = v->index;

   200

   201

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

   202

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

   203

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

   204

		// On hold for NewAI

   205

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

   206

   207

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

   208

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

   209

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

   210

		*/

   211

		{

   212

			Station *st;

   213

			const AirportFTAClass *Airport;

   214

			const uint16 *cur_depot;

   215

			byte i = 0;

   216

			st = DEREF_STATION(_map2[tile]);

   217

			Airport = GetAirport(st->airport_type);

   218

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

   219

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

   220

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

   221

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

   222

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

   223

					break;

   224

				}

   225

				i++;

   226

			}

   227

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

   228

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

   229

		}

   230

   231

		v->u.air.state = HANGAR;

   232

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

   233

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

   234

		v->next = u;

   235

   236

		v->service_interval = _patches.servint_aircraft;

   237

   238

		v->date_of_last_service = _date;

   239

		v->build_year = _cur_year;

   240

   241

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

   242

   243

		VehiclePositionChanged(v);

   244

		VehiclePositionChanged(u);

   245

   246

		// Aircraft with 3 vehicles?

   247

		if (v->subtype == 0) {

   248

			w = vl[2];

   249

   250

			u->next = w;

   251

   252

			w->type = VEH_Aircraft;

   253

			w->direction = 0;

   254

			w->owner = _current_player;

   255

			w->x_pos = v->x_pos;

   256

			w->y_pos = v->y_pos;

   257

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

   258

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

   259

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

   260

			w->z_height = 1;

   261

			w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE;

   262

			w->subtype = 6;

   263

			w->cur_image = 0xF3D;

   264

			VehiclePositionChanged(w);

   265

		}

   266

   267

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   268

		_vehicle_sort_dirty[VEHAIRCRAFT] = true; // build aircraft

   269

		InvalidateWindow(WC_AIRCRAFT_LIST, v->owner);

   270

		InvalidateWindow(WC_COMPANY, v->owner);

   271

	}

   272

   273

	return value;

   274

}

   275

   276

bool IsAircraftHangarTile(TileIndex tile)

   277

{

   278

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

   279

	// 0x20 - hangar large airport (32)

   280

	// 0x41 - hangar small airport (65)

   281

	return IS_TILETYPE(tile, MP_STATION) &&

   282

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

   283

}

   284

   285

static bool CheckStoppedInHangar(Vehicle *v)

   286

{

   287

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

   288

			!IsAircraftHangarTile(v->tile)) {

   289

		_error_message = STR_A01B_AIRCRAFT_MUST_BE_STOPPED;

   290

		return false;

   291

	}

   292

   293

	return true;

   294

}

   295

   296

   297

static void DoDeleteAircraft(Vehicle *v)

   298

{

   299

	DeleteWindowById(WC_VEHICLE_VIEW, v->index);

   300

	_vehicle_sort_dirty[VEHAIRCRAFT] = true; // delete aircraft

   301

	InvalidateWindow(WC_AIRCRAFT_LIST, v->owner);

   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, 4);

   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->next_order&OT_MASK) == OT_GOTO_DEPOT) {

   365

		if (flags & DC_EXEC) {

   366

 			if (v->next_order&OF_UNLOAD)

   367

 				{ v->cur_order_index++; }

   368

			v->next_order = OT_DUMMY;

   369

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

   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->next_order = OF_NON_STOP | OF_FULL_LOAD | OT_GOTO_DEPOT;

   380

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

   381

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

   382

		}

   383

	}

   384

   385

	return 0;

   386

}

   387

   388

// p1 = vehicle

   389

// p2 = new service int

   390

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

   391

{

   392

	Vehicle *v;

   393

   394

	v = &_vehicles[p1];

   395

   396

	if (!CheckOwnership(v->owner))

   397

		return CMD_ERROR;

   398

   399

	if (flags & DC_EXEC) {

   400

		v->service_interval = (uint16)p2;

   401

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

   402

	}

   403

   404

	return 0;

   405

}

   406

   407

// p1 = vehicle

   408

// p2 = new cargo type

   409

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

   410

{

   411

	Vehicle *v,*u;

   412

	int pass, mail;

   413

	int32 cost;

   414

   415

	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN);

   416

   417

	v = &_vehicles[p1];

   418

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

   419

		return CMD_ERROR;

   420

   421

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

   422

	if (p2 != 0) {

   423

		pass >>= 1;

   424

		if (p2 != 5)

   425

			pass >>= 1;

   426

	}

   427

	_aircraft_refit_capacity = pass;

   428

   429

	cost = 0;

   430

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

   431

		cost = _price.aircraft_base >> 7;

   432

	}

   433

   434

	if (flags & DC_EXEC) {

   435

		v->cargo_cap = pass;

   436

   437

		u = v->next;

   438

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

   439

		if (p2 != 0) {

   440

			mail = 0;

   441

		}

   442

		u->cargo_cap = mail;

   443

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

   444

		v->cargo_type = (byte)p2;

   445

		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);

   446

	}

   447

   448

	return cost;

   449

}

   450

   451

void HandleClickOnAircraft(Vehicle *v)

   452

{

   453

	ShowAircraftViewWindow(v);

   454

}

   455

   456

static void CheckIfAircraftNeedsService(Vehicle *v)

   457

{

   458

	Station *st;

   459

   460

	if (_patches.servint_aircraft == 0)

   461

		return;

   462

   463

	if (SERVICE_INTERVAL)

   464

		return;

   465

   466

	if (v->vehstatus & VS_STOPPED)

   467

		return;

   468

   469

	if ((v->next_order & (OT_MASK | OF_FULL_LOAD)) == (OT_GOTO_DEPOT | OF_FULL_LOAD))

   470

		return;

   471

   472

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

   473

 		return;

   474

   475

	st = DEREF_STATION(v->next_order_param);

   476

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

   477

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

   478

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

   479

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

   480

		v->next_order = OF_NON_STOP | OT_GOTO_DEPOT;

   481

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

   482

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

   483

		v->next_order = OT_DUMMY;

   484

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

   485

	}

   486

}

   487

   488

void OnNewDay_Aircraft(Vehicle *v)

   489

{

   490

	int32 cost;

   491

   492

	if (v->subtype > 2)

   493

		return;

   494

   495

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

   496

		DecreaseVehicleValue(v);

   497

   498

	CheckOrders(v);

   499

   500

	CheckVehicleBreakdown(v);

   501

	AgeVehicle(v);

   502

	CheckIfAircraftNeedsService(v);

   503

   504

	if (v->vehstatus & VS_STOPPED)

   505

		return;

   506

   507

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

   508

   509

	v->profit_this_year -= cost >> 8;

   510

   511

	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN);

   512

	SubtractMoneyFromPlayerFract(v->owner, cost);

   513

   514

	InvalidateWindow(WC_VEHICLE_DETAILS, v->index);

   515

	InvalidateWindow(WC_AIRCRAFT_LIST, v->owner);

   516

}

   517

   518

void AircraftYearlyLoop()

   519

{

   520

	Vehicle *v;

   521

   522

	FOR_ALL_VEHICLES(v) {

   523