1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "vehicle.h"

     4

#include "engine.h"

     5

#include "command.h"

     6

#include "station.h"

     7

#include "news.h"

     8

#include "gfx.h"

     9

#include "sound.h"

    10

#include "player.h"

    11

#include "airport.h"

    12

    13

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

    14

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

    15

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

    16

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

    17

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

    18

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

    19

    20

static void AircraftNextAirportPos_and_Order(Vehicle *v);

    21

static byte GetAircraftFlyingAltitude(const Vehicle *v);

    22

    23

static const SpriteID _aircraft_sprite[] = {

    24

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

    25

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

    26

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

    27

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

    28

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

    29

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

    30

	0x0EBD, 0x0EC5

    31

};

    32

    33

int GetAircraftImage(Vehicle *v, byte direction)

    34

{

    35

	int spritenum = v->spritenum;

    36

    37

	if (is_custom_sprite(spritenum)) {

    38

		int sprite = GetCustomVehicleSprite(v, direction);

    39

    40

		if (sprite) return sprite;

    41

		spritenum = _engine_original_sprites[v->engine_type];

    42

	}

    43

	return direction + _aircraft_sprite[spritenum];

    44

}

    45

    46

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

    47

{

    48

	int spritenum = aircraft_vehinfo(engine).image_index;

    49

    50

	if (is_custom_sprite(spritenum)) {

    51

		int sprite = GetCustomVehicleIcon(engine, 6);

    52

    53

		if (sprite) {

    54

			DrawSprite(sprite | image_ormod, x, y);

    55

			return;

    56

		}

    57

		spritenum = _engine_original_sprites[engine];

    58

	}

    59

    60

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

    61

    62

	if ((aircraft_vehinfo(engine).subtype & 1) == 0)

    63

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

    64

}

    65

    66

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

    67

{

    68

	SET_DPARAM32(0, ((_price.aircraft_base >> 3) * aircraft_vehinfo(engine).base_cost) >> 5);

    69

	SET_DPARAM16(1, aircraft_vehinfo(engine).max_speed << 3);

    72

	SET_DPARAM32(4, aircraft_vehinfo(engine).running_cost * _price.aircraft_running >> 8);

    73

    74

	DrawStringMultiCenter(x, y, STR_A02E_COST_MAX_SPEED_CAPACITY, maxw);

    75

}

    76

    77

/* Allocate many vehicles */

    78

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

    79

{

    80

	int i;

    81

	Vehicle *v;

    82

	bool success = true;

    83

    84

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

    85

		vl[i] = v = AllocateVehicle();

    86

		if (v == NULL) {

    87

			success = false;

    88

			break;

    89

		}

    90

		v->type = 1;

    91

	}

    92

    93

	while (--i >= 0) {

    94

		vl[i]->type = 0;

    95

	}

    96

    97

	return success;

    98

}

    99

   100

static int32 EstimateAircraftCost(uint16 engine_type)

   101

{

   102

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

   103

}

   104

   105

   106

/* p1 = engine */

   107

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

   108

{

   109

	int32 value;

   110

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

   111

	byte unit_num;

   112

	uint tile = TILE_FROM_XY(x,y);

   113

	Engine *e;

   114

   115

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   116

   117

	value = EstimateAircraftCost(p1);

   118

   119

	if (flags & DC_QUERY_COST)

   120

		return value;

   121

   122

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

   123

	if (!AllocateVehicles(vl, (aircraft_vehinfo(p1).subtype & 1) == 0 ? 3 : 2) ||

   124

			_ptr_to_next_order >= endof(_order_array))

   125

					return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   126

   127

	unit_num = GetFreeUnitNumber(VEH_Aircraft);

   128

	if (unit_num > _patches.max_aircraft)

   129

		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   130

   131

	if (flags & DC_EXEC) {

   132

		v = vl[0];

   133

		u = vl[1];

   134

   135

		v->unitnumber = unit_num;

   136

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

   137

		v->direction = 3;

   138

   139

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

   140

   141

		v->tile = tile;

   142

//		u->tile = 0;

   143

   144

		x = GET_TILE_X(tile)*16 + 5;

   145

		y = GET_TILE_Y(tile)*16 + 3;

   146

   147

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

   148

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

   149

   150

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

   151

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

   152

   153

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

   154

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

   155

   156

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

   157

		v->z_height = 5;

   158

   159

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

   160

		u->z_height = 1;

   161

   162

		v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

   163

		u->vehstatus = VS_HIDDEN | VS_UNCLICKABLE | VS_DISASTER;

   164

   165

		v->spritenum = aircraft_vehinfo(p1).image_index;

   166

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

   167

   168

		v->cargo_cap = aircraft_vehinfo(p1).passanger_capacity;

   169

		u->cargo_cap = aircraft_vehinfo(p1).mail_capacity;

   170

   171

		v->cargo_type = CT_PASSENGERS;

   172

		u->cargo_type = CT_MAIL;

   173

   174

		v->string_id = STR_SV_AIRCRAFT_NAME;

   175

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

   176

   177

//		v->load_unload_time_rem = 0;

   178

//		v->progress = 0;

   179

		v->last_station_visited = 0xFF;

   180

//		v->destination_coords = 0;

   181

   182

		v->max_speed = aircraft_vehinfo(p1).max_speed;

   183

		v->acceleration = aircraft_vehinfo(p1).acceleration;

   184

		v->engine_type = (byte)p1;

   185

   186

		v->subtype = (aircraft_vehinfo(p1).subtype & 1) == 0 ? 0 : 2;

   187

		v->value = value;

   188

   189

		u->subtype = 4;

   190

   191

		e = &_engines[p1];

   192

		v->reliability = e->reliability;

   193

		v->reliability_spd_dec = e->reliability_spd_dec;

   194

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

   195

   196

		_new_aircraft_id = v->index;

   197

   198

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

   199

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

   200

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

   201

		// On hold for NewAI

   202

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

   203

   204

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

   205

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

   206

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

   207

		*/

   208

		{

   209

			Station *st;

   210

			const AirportFTAClass *Airport;

   211

			const uint16 *cur_depot;

   212

			byte i = 0;

   213

			st = DEREF_STATION(_map2[tile]);

   214

			Airport = GetAirport(st->airport_type);

   215

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

   216

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

   217

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

   218

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

   219

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

   220

					break;

   221

				}

   222

				i++;

   223

			}

   224

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

   225

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

   226

		}

   227

   228

		v->u.air.state = HANGAR;

   229

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

   230

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

   231

		v->next = u;

   232

   233

		v->service_interval = _patches.servint_aircraft;

   234

   235

		v->date_of_last_service = _date;

   236

		v->build_year = _cur_year;

   237

   238

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

   239

   240

		VehiclePositionChanged(v);

   241

		VehiclePositionChanged(u);

   242

   243

		// Aircraft with 3 vehicles?

   244

		if (v->subtype == 0) {

   245

			w = vl[2];

   246

   247

			u->next = w;

   248

   249

			w->type = VEH_Aircraft;

   250

			w->direction = 0;

   251

			w->owner = _current_player;

   252

			w->x_pos = v->x_pos;

   253

			w->y_pos = v->y_pos;

   254

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

   255

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

   256

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

   257

			w->z_height = 1;

   258

			w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE;

   259

			w->subtype = 6;

   260

			w->cur_image = 0xF3D;

   261

			VehiclePositionChanged(w);

   262

		}

   263

   264

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   265

		_vehicle_sort_dirty[VEHAIRCRAFT] = true; // build aircraft

   266

		InvalidateWindow(WC_AIRCRAFT_LIST, v->owner);

   267

		InvalidateWindow(WC_COMPANY, v->owner);

   268

	}

   269

   270

	return value;

   271

}

   272

   273

bool IsAircraftHangarTile(TileIndex tile)

   274

{

   275

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

   276

	// 0x20 - hangar large airport (32)

   277

	// 0x41 - hangar small airport (65)

   278

	return IS_TILETYPE(tile, MP_STATION) &&

   279

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

   280

}

   281

   282

static bool CheckStoppedInHangar(Vehicle *v)

   283

{

   284

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

   285

			!IsAircraftHangarTile(v->tile)) {

   286

		_error_message = STR_A01B_AIRCRAFT_MUST_BE_STOPPED;

   287

		return false;

   288

	}

   289

   290

	return true;

   291

}

   292

   293

   294

static void DoDeleteAircraft(Vehicle *v)

   295

{

   296

	DeleteWindowById(WC_VEHICLE_VIEW, v->index);

   297

	_vehicle_sort_dirty[VEHAIRCRAFT] = true; // delete aircraft

   298

	InvalidateWindow(WC_AIRCRAFT_LIST, v->owner);

   299

	InvalidateWindow(WC_COMPANY, v->owner);

   300

	DeleteVehicleChain(v);

   301

}

   302

   303

// p1 = vehicle

   304

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

   305

{

   306

	Vehicle *v;

   307

   308

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   309

   310

	v = &_vehicles[p1];

   311

   312

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

   313

		return CMD_ERROR;

   314

   315

	if (flags & DC_EXEC) {

   316

		// Invalidate depot

   317

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   318

   319

		DoDeleteAircraft(v);

   320

   321

	}

   322

   323

	return -(int32)v->value;

   324

}

   325

   326

// p1 = vehicle

   327

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

   328

{

   329

	Vehicle *v;

   330

   331

	v = &_vehicles[p1];

   332

   333

	if (!CheckOwnership(v->owner))

   334

		return CMD_ERROR;

   335

   336

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

   337

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

   338

		return_cmd_error(STR_A017_AIRCRAFT_IS_IN_FLIGHT);

   339

	}

   340

   341

	if (flags & DC_EXEC) {

   342

		v->vehstatus ^= VS_STOPPED;

   343

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

   344

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   345

	}

   346

   347

	return 0;

   348

}

   349

   350

// p1 = vehicle

   351

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

   352

{

   353

	Vehicle *v;

   354

	Station *st;

   355

   356

	v = &_vehicles[p1];

   357

   358

	if (!CheckOwnership(v->owner))

   359

		return CMD_ERROR;

   360

   361

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

   362

		if (flags & DC_EXEC) {

   363

 			if (v->next_order&OF_UNLOAD)

   364

 				{ v->cur_order_index++; }

   365

			v->next_order = OT_DUMMY;

   366

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

   367

		}

   368

	} else {

   369

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

   370

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

   371

		// it surely doesn't have any hangars

   372

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

   373

					return CMD_ERROR;

   374

   375

		if (flags & DC_EXEC) {

   376

			v->next_order = OF_NON_STOP | OF_FULL_LOAD | OT_GOTO_DEPOT;

   377

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

   378

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

   379

		}

   380

	}

   381

   382

	return 0;

   383

}

   384

   385

// p1 = vehicle

   386

// p2 = new service int

   387

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

   388

{

   389

	Vehicle *v;

   390

   391

	v = &_vehicles[p1];

   392

   393

	if (!CheckOwnership(v->owner))

   394

		return CMD_ERROR;

   395

   396

	if (flags & DC_EXEC) {

   397

		v->service_interval = (uint16)p2;

   398

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

   399

	}

   400

   401

	return 0;

   402

}

   403

   404

// p1 = vehicle

   405

// p2 = new cargo type

   406

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

   407

{

   408

	Vehicle *v,*u;

   409

	int pass, mail;

   410

	int32 cost;

   411

   412

	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN);

   413

   414

	v = &_vehicles[p1];

   415

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

   416

		return CMD_ERROR;

   417

   418

	pass = aircraft_vehinfo(v->engine_type).passanger_capacity;

   419

	if (p2 != 0) {

   420

		pass >>= 1;

   421

		if (p2 != 5)

   422

			pass >>= 1;

   423

	}

   424

	_aircraft_refit_capacity = pass;

   425

   426

	cost = 0;

   427

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

   428

		cost = _price.aircraft_base >> 7;

   429

	}

   430

   431

	if (flags & DC_EXEC) {

   432

		v->cargo_cap = pass;

   433

   434

		u = v->next;

   435

		mail = aircraft_vehinfo(v->engine_type).mail_capacity;

   436

		if (p2 != 0) {

   437

			mail = 0;

   438

		}

   439

		u->cargo_cap = mail;

   440

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

   441

		v->cargo_type = (byte)p2;

   442

		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);

   443

	}

   444

   445

	return cost;

   446

}

   447

   448

void HandleClickOnAircraft(Vehicle *v)

   449

{

   450

	ShowAircraftViewWindow(v);

   451

}

   452

   453

static void CheckIfAircraftNeedsService(Vehicle *v)

   454

{

   455

	Station *st;

   456

   457

	if (_patches.servint_aircraft == 0)

   458

		return;

   459

   460

	if (SERVICE_INTERVAL)

   461

		return;

   462

   463

	if (v->vehstatus & VS_STOPPED)

   464

		return;

   465

   466

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

   467

		return;

   468

   469

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

   470

 		return;

   471

   472

	st = DEREF_STATION(v->next_order_param);

   473

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

   474

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

   475

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

   476

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

   477

		v->next_order = OF_NON_STOP | OT_GOTO_DEPOT;

   478

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

   479

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

   480

		v->next_order = OT_DUMMY;

   481

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

   482

	}

   483

}

   484

   485

void OnNewDay_Aircraft(Vehicle *v)

   486

{

   487

	int32 cost;

   488

   489

	if (v->subtype > 2)

   490

		return;

   491

   492

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

   493

		DecreaseVehicleValue(v);

   494

   495

	CheckOrders(v);

   496

   497

	CheckVehicleBreakdown(v);

   498

	AgeVehicle(v);

   499

	CheckIfAircraftNeedsService(v);

   500

   501

	if (v->vehstatus & VS_STOPPED)

   502

		return;

   503

   504

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

   505

   506

	v->profit_this_year -= cost >> 8;

   507

   508

	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN);

   509

	SubtractMoneyFromPlayerFract(v->owner, cost);

   510

   511

	InvalidateWindow(WC_VEHICLE_DETAILS, v->index);

   512

	InvalidateWindow(WC_AIRCRAFT_LIST, v->owner);

   513

}

   514

   515

void AircraftYearlyLoop()

   516

{

   517

	Vehicle *v;

   518

   519

	FOR_ALL_VEHICLES(v) {

   520

		if (v->type == VEH_Aircraft && v->subtype <= 2) {

   521

			v->profit_last_year = v->profit_this_year;

   522

			v->profit_this_year = 0;

   523

			InvalidateWindow(WC_VEHICLE_DETAILS, v->index);