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

static 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 = 0xFF;

   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;

   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;

   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;

   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

   410

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

   411

{

   412

	Vehicle *v,*u;

   413

	int pass, mail;

   414

	int32 cost;

   415

   416

	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN);

   417

   418

	v = &_vehicles[p1];

   419

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

   420

		return CMD_ERROR;

   421

   422

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

   423

	if (p2 != 0) {

   424

		pass >>= 1;

   425

		if (p2 != 5)

   426

			pass >>= 1;

   427

	}

   428

	_aircraft_refit_capacity = pass;

   429

   430

	cost = 0;

   431

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

   432

		cost = _price.aircraft_base >> 7;

   433

	}

   434

   435

	if (flags & DC_EXEC) {

   436

		v->cargo_cap = pass;

   437

   438

		u = v->next;

   439

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

   440

		if (p2 != 0) {

   441

			mail = 0;

   442

		}

   443

		u->cargo_cap = mail;

   444

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

   445

		v->cargo_type = (byte)p2;

   446

		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);

   447

	}

   448

   449

	return cost;

   450

}

   451

   452

void HandleClickOnAircraft(Vehicle *v)

   453

{

   454

	ShowAircraftViewWindow(v);

   455

}

   456

   457

static void CheckIfAircraftNeedsService(Vehicle *v)

   458

{

   459

	Station *st;

   460

   461

	if (_patches.servint_aircraft == 0)

   462

		return;

   463

   464

	if (!VehicleNeedsService(v))

   465

		return;

   466

   467

	if (v->vehstatus & VS_STOPPED)

   468

		return;

   469

   470

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

   471

			v->current_order.flags & OF_FULL_LOAD)

   472

		return;

   473

   474

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

   475

 		return;

   476

   477

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

   478

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

   479

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

   480

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

   481

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

   482

		v->current_order.type = OT_GOTO_DEPOT;

   483

		v->current_order.flags = OF_NON_STOP;

   485

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

   486

		v->current_order.type = OT_DUMMY;

   487

		v->current_order.flags = 0;

   489

	}

   490

}

   491

   492

void OnNewDay_Aircraft(Vehicle *v)

   493

{

   494

	int32 cost;

   495

   496

	if (v->subtype > 2)

   497

		return;

   498

   499

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

   500

		DecreaseVehicleValue(v);

   501

   502

	CheckOrders(v);

   503

   504

	CheckVehicleBreakdown(v);

   505

	AgeVehicle(v);

   506

	CheckIfAircraftNeedsService(v);

   507

   508

	if (v->vehstatus & VS_STOPPED)

   509

		return;

   510

   511

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

   512

   513

	v->profit_this_year -= cost >> 8;

   514

   515

	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN);

   516

	SubtractMoneyFromPlayerFract(v->owner, cost);

   517

   518

	InvalidateWindow(WC_VEHICLE_DETAILS, v->index);

   519

	InvalidateWindow(WC_AIRCRAFT_LIST, v->owner);