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

	engine -= AIRCRAFT_ENGINES_INDEX;

    69

    70

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

    71

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

    72

	SET_DPARAM16(2, aircraft_vehinfo(engine).mail_capacity);

    73

	SET_DPARAM16(3, aircraft_vehinfo(engine).passanger_capacity);

    74

	SET_DPARAM32(4, aircraft_vehinfo(engine).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

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 aircraft_vehinfo(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

	Engine *e;

   116

   117

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   118

   119

	value = EstimateAircraftCost(p1);

   120

   121

	if (flags & DC_QUERY_COST)

   122

		return value;

   123

   124

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

   125

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

   126

			_ptr_to_next_order >= endof(_order_array))

   127

					return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   128

   129

	unit_num = GetFreeUnitNumber(VEH_Aircraft);

   130

	if (unit_num > _patches.max_aircraft)

   131

		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   132

   133

	if (flags & DC_EXEC) {

   134

		v = vl[0];

   135

		u = vl[1];

   136

   137

		v->unitnumber = unit_num;

   138

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

   139

		v->direction = 3;

   140

   141

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

   142

   143

		v->tile = tile;

   144

//		u->tile = 0;

   145

   146

		x = GET_TILE_X(tile)*16 + 5;

   147

		y = GET_TILE_Y(tile)*16 + 3;

   148

   149

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

   150

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

   151

   152

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

   153

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

   154

   155

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

   156

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

   157

   158

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

   159

		v->z_height = 5;

   160

   161

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

   162

		u->z_height = 1;

   163

   164

		v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

   165

		u->vehstatus = VS_HIDDEN | VS_UNCLICKABLE | VS_DISASTER;

   166

   167

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

   168

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

   169

   170

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

   171

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

   172

   173

		v->cargo_type = CT_PASSENGERS;

   174

		u->cargo_type = CT_MAIL;

   175

   176

		v->string_id = STR_SV_AIRCRAFT_NAME;

   177

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

   178

   179

//		v->load_unload_time_rem = 0;

   180

//		v->progress = 0;

   181

		v->last_station_visited = 0xFF;

   182

//		v->destination_coords = 0;

   183

   184

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

   185

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

   186

		v->engine_type = (byte)p1;

   187

   188

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

   189

		v->value = value;

   190

   191

		u->subtype = 4;

   192

   193

		e = &_engines[p1];

   194

		v->reliability = e->reliability;

   195

		v->reliability_spd_dec = e->reliability_spd_dec;

   196

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

   197

   198

		_new_aircraft_id = v->index;

   199

   200

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

   201

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

   202

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

   203

		// On hold for NewAI

   204

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

   205

   206

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

   207

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

   208

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

   209

		*/

   210

		{

   211

			Station *st;

   212

			const AirportFTAClass *Airport;

   213

			const uint16 *cur_depot;

   214

			byte i = 0;

   215

			st = DEREF_STATION(_map2[tile]);

   216

			Airport = GetAirport(st->airport_type);

   217

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

   218

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

   219

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

   220

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

   221

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

   222

					break;

   223

				}

   224

				i++;

   225

			}

   226

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

   227

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

   228

		}

   229

   230

		v->u.air.state = HANGAR;

   231

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

   232

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

   233

		v->next = u;

   234

   235

		v->service_interval = _patches.servint_aircraft;

   236

   237

		v->date_of_last_service = _date;

   238

		v->build_year = _cur_year;

   239

   240

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

   241

   242

		VehiclePositionChanged(v);

   243

		VehiclePositionChanged(u);

   244

   245

		// Aircraft with 3 vehicles?

   246

		if (v->subtype == 0) {

   247

			w = vl[2];

   248

   249

			u->next = w;

   250

   251

			w->type = VEH_Aircraft;

   252

			w->direction = 0;

   253

			w->owner = _current_player;

   254

			w->x_pos = v->x_pos;

   255

			w->y_pos = v->y_pos;

   256

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

   257

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

   258

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

   259

			w->z_height = 1;

   260

			w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE;

   261

			w->subtype = 6;

   262

			w->cur_image = 0xF3D;

   263

			VehiclePositionChanged(w);

   264

		}

   265

   266

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   267

		_vehicle_sort_dirty[VEHAIRCRAFT] = true; // build aircraft

   268

		InvalidateWindow(WC_AIRCRAFT_LIST, v->owner);

   269

		InvalidateWindow(WC_COMPANY, v->owner);

   270

	}

   271

   272

	return value;

   273

}

   274

   275

bool IsAircraftHangarTile(TileIndex tile)

   276

{

   277

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

   278

	// 0x20 - hangar large airport (32)

   279

	// 0x41 - hangar small airport (65)

   280

	return IS_TILETYPE(tile, MP_STATION) &&

   281

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

   282

}

   283

   284

static bool CheckStoppedInHangar(Vehicle *v)

   285

{

   286

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

   287

			!IsAircraftHangarTile(v->tile)) {

   288

		_error_message = STR_A01B_AIRCRAFT_MUST_BE_STOPPED;

   289

		return false;

   290

	}

   291

   292

	return true;

   293

}

   294

   295

   296

void DoDeleteAircraft(Vehicle *v)

   297

{

   298

	DeleteWindowById(WC_VEHICLE_VIEW, v->index);

   299

	_vehicle_sort_dirty[VEHAIRCRAFT] = true; // delete aircraft

   300

	InvalidateWindow(WC_AIRCRAFT_LIST, v->owner);

   301

	InvalidateWindow(WC_COMPANY, v->owner);

   302

	DeleteVehicleChain(v);

   303

}

   304

   305

// p1 = vehicle

   306

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

   307

{

   308

	Vehicle *v;

   309

   310

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   311

   312

	v = &_vehicles[p1];

   313

   314

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

   315

		return CMD_ERROR;

   316

   317

	if (flags & DC_EXEC) {

   318

		// Invalidate depot

   319

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   320

   321

		DoDeleteAircraft(v);

   322

   323

	}

   324

   325

	return -(int32)v->value;

   326

}

   327

   328

// p1 = vehicle

   329

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

   330

{

   331

	Vehicle *v;

   332

   333

	v = &_vehicles[p1];

   334

   335

	if (!CheckOwnership(v->owner))

   336

		return CMD_ERROR;

   337

   338

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

   339

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

   340

		return_cmd_error(STR_A017_AIRCRAFT_IS_IN_FLIGHT);

   341

	}

   342

   343

	if (flags & DC_EXEC) {

   344

		v->vehstatus ^= VS_STOPPED;

   345

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

   346

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   347

	}

   348

   349

	return 0;

   350

}

   351

   352

// p1 = vehicle

   353

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

   354

{

   355

	Vehicle *v;

   356

	Station *st;

   357

   358

	v = &_vehicles[p1];

   359

   360

	if (!CheckOwnership(v->owner))

   361

		return CMD_ERROR;

   362

   363

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

   364

		if (flags & DC_EXEC) {

   365

 			if (v->next_order&OF_UNLOAD)

   366

 				{ v->cur_order_index++; }

   367

			v->next_order = OT_DUMMY;

   368

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

   369

		}

   370

	} else {

   371

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

   372

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

   373

		// it surely doesn't have any hangars

   374

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

   375

					return CMD_ERROR;

   376

   377

		if (flags & DC_EXEC) {

   378

			v->next_order = OF_NON_STOP | OF_FULL_LOAD | OT_GOTO_DEPOT;

   379

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

   380

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

   381

		}

   382

	}

   383

   384

	return 0;

   385

}

   386

   387

// p1 = vehicle

   388

// p2 = new service int

   389

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

   390

{

   391

	Vehicle *v;

   392

   393

	v = &_vehicles[p1];

   394

   395

	if (!CheckOwnership(v->owner))

   396

		return CMD_ERROR;

   397

   398

	if (flags & DC_EXEC) {

   399

		v->service_interval = (uint16)p2;

   400

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

   401

	}

   402

   403

	return 0;

   404

}

   405

   406

// p1 = vehicle

   407

// p2 = new cargo type

   408

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

   409

{

   410

	Vehicle *v,*u;

   411

	int pass, mail;

   412

	int32 cost;

   413

   414

	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN);

   415

   416

	v = &_vehicles[p1];

   417

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

   418

		return CMD_ERROR;

   419

   420

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

   421

	if (p2 != 0) {

   422

		pass >>= 1;

   423

		if (p2 != 5)

   424

			pass >>= 1;

   425

	}

   426

	_aircraft_refit_capacity = pass;

   427

   428

	cost = 0;

   429

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

   430

		cost = _price.aircraft_base >> 7;

   431

	}

   432

   433

	if (flags & DC_EXEC) {

   434

		v->cargo_cap = pass;

   435

   436

		u = v->next;

   437

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

   438

		if (p2 != 0) {

   439

			mail = 0;

   440

		}

   441

		u->cargo_cap = mail;

   442

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

   443

		v->cargo_type = (byte)p2;

   444

		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);

   445

	}

   446

   447

	return cost;

   448

}

   449

   450

void HandleClickOnAircraft(Vehicle *v)

   451

{

   452

	ShowAircraftViewWindow(v);

   453

}

   454

   455

static void CheckIfAircraftNeedsService(Vehicle *v)

   456

{

   457

	Station *st;

   458

   459

	if (_patches.servint_aircraft == 0)

   460

		return;

   461

   462

	if (SERVICE_INTERVAL)

   463

		return;

   464

   465

	if (v->vehstatus & VS_STOPPED)

   466

		return;

   467

   468

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

   469

		return;

   470

   471

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

   472

 		return;

   473

   474

	st = DEREF_STATION(v->next_order_param);

   475

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

   476

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

   477

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

   478

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

   479

		v->next_order = OF_NON_STOP | OT_GOTO_DEPOT;

   480

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

   481

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

   482

		v->next_order = OT_DUMMY;

   483

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

   484

	}

   485

}

   486

   487

void OnNewDay_Aircraft(Vehicle *v)

   488

{

   489

	int32 cost;

   490

   491

	if (v->subtype > 2)

   492

		return;

   493

   494

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

   495

		DecreaseVehicleValue(v);

   496

   497

	CheckOrders(v);

   498

   499

	CheckVehicleBreakdown(v);

   500

	AgeVehicle(v);

   501

	CheckIfAircraftNeedsService(v);

   502

   503

	if (v->vehstatus & VS_STOPPED)

   504

		return;

   505

   506

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

   507

   508

	v->profit_this_year -= cost >> 8;

   509

   510

	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN);

   511

	SubtractMoneyFromPlayerFract(v->owner, cost);

   512

   513

	InvalidateWindow(WC_VEHICLE_DETAILS, v->index);

   514

	InvalidateWindow(WC_AIRCRAFT_LIST, v->owner);

   515

}

   516

   517

void AircraftYearlyLoop()

   518

{

   519

	Vehicle *v;

   520

   521

	FOR_ALL_VEHICLES(v) {

   522

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

   523

			v->profit_last_year = v->profit_this_year;

   524