1

/* $Id$ */

     2

     3

/** @file airport.cpp Functions related to airports. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "debug.h"

     8

#include "airport.h"

     9

#include "airport_movement.h"

    10

#include "core/bitmath_func.hpp"

    11

#include "core/alloc_func.hpp"

    12

#include "date_func.h"

    13

#include "settings_type.h"

    14

    15

/* Uncomment this to print out a full report of the airport-structure

    16

 * You should either use

    17

 * - true: full-report, print out every state and choice with string-names

    18

 * OR

    19

 * - false: give a summarized report which only shows current and next position */

    20

//#define DEBUG_AIRPORT false

    21

    22

static AirportFTAClass *DummyAirport;

    23

static AirportFTAClass *CountryAirport;

    24

static AirportFTAClass *CityAirport;

    25

static AirportFTAClass *Oilrig;

    26

static AirportFTAClass *Heliport;

    27

static AirportFTAClass *MetropolitanAirport;

    28

static AirportFTAClass *InternationalAirport;

    29

static AirportFTAClass *CommuterAirport;

    30

static AirportFTAClass *HeliDepot;

    31

static AirportFTAClass *IntercontinentalAirport;

    32

static AirportFTAClass *HeliStation;

    33

    34

    35

void InitializeAirports()

    36

{

    37

	DummyAirport = new AirportFTAClass(

    38

		_airport_moving_data_dummy,

    39

		NULL,

    40

		NULL,

    41

		_airport_entries_dummy,

    42

		AirportFTAClass::ALL,

    43

		_airport_fta_dummy,

    44

		NULL,

    45

		0,

    46

		0, 0, 0,

    47

		0,

    48

		0

    49

	);

    50

    51

	CountryAirport = new AirportFTAClass(

    52

		_airport_moving_data_country,

    53

		_airport_terminal_country,

    54

		NULL,

    55

		_airport_entries_country,

    56

		AirportFTAClass::ALL | AirportFTAClass::SHORT_STRIP,

    57

		_airport_fta_country,

    58

		_airport_depots_country,

    59

		lengthof(_airport_depots_country),

    60

		4, 3, 3,

    61

		0,

    62

		4

    63

	);

    64

    65

	CityAirport = new AirportFTAClass(

    66

		_airport_moving_data_town,

    67

		_airport_terminal_city,

    68

		NULL,

    69

		_airport_entries_city,

    70

		AirportFTAClass::ALL,

    71

		_airport_fta_city,

    72

		_airport_depots_city,

    73

		lengthof(_airport_depots_city),

    74

		6, 6, 5,

    75

		0,

    76

		5

    77

	);

    78

    79

	MetropolitanAirport = new AirportFTAClass(

    80

		_airport_moving_data_metropolitan,

    81

		_airport_terminal_metropolitan,

    82

		NULL,

    83

		_airport_entries_metropolitan,

    84

		AirportFTAClass::ALL,

    85

		_airport_fta_metropolitan,

    86

		_airport_depots_metropolitan,

    87

		lengthof(_airport_depots_metropolitan),

    88

		6, 6, 8,

    89

		0,

    90

		6

    91

	);

    92

    93

	InternationalAirport = new AirportFTAClass(

    94

		_airport_moving_data_international,

    95

		_airport_terminal_international,

    96

		_airport_helipad_international,

    97

		_airport_entries_international,

    98

		AirportFTAClass::ALL,

    99

		_airport_fta_international,

   100

		_airport_depots_international,

   101

		lengthof(_airport_depots_international),

   102

		7, 7, 17,

   103

		0,

   104

		8

   105

	);

   106

   107

	IntercontinentalAirport = new AirportFTAClass(

   108

		_airport_moving_data_intercontinental,

   109

		_airport_terminal_intercontinental,

   110

		_airport_helipad_intercontinental,

   111

		_airport_entries_intercontinental,

   112

		AirportFTAClass::ALL,

   113

		_airport_fta_intercontinental,

   114

		_airport_depots_intercontinental,

   115

		lengthof(_airport_depots_intercontinental),

   116

		9, 11, 25,

   117

		0,

   118

		10

   119

	);

   120

   121

	Heliport = new AirportFTAClass(

   122

		_airport_moving_data_heliport,

   123

		NULL,

   124

		_airport_helipad_heliport_oilrig,

   125

		_airport_entries_heliport_oilrig,

   126

		AirportFTAClass::HELICOPTERS,

   127

		_airport_fta_heliport_oilrig,

   128

		NULL,

   129

		0,

   130

		1, 1, 1,

   131

		60,

   132

		4

   133

	);

   134

   135

	Oilrig = new AirportFTAClass(

   136

		_airport_moving_data_oilrig,

   137

		NULL,

   138

		_airport_helipad_heliport_oilrig,

   139

		_airport_entries_heliport_oilrig,

   140

		AirportFTAClass::HELICOPTERS,

   141

		_airport_fta_heliport_oilrig,

   142

		NULL,

   143

		0,

   144

		1, 1, 0,

   145

		54,

   146

		3

   147

	);

   148

   149

	CommuterAirport = new AirportFTAClass(

   150

		_airport_moving_data_commuter,

   151

		_airport_terminal_commuter,

   152

		_airport_helipad_commuter,

   153

		_airport_entries_commuter,

   154

		AirportFTAClass::ALL | AirportFTAClass::SHORT_STRIP,

   155

		_airport_fta_commuter,

   156

		_airport_depots_commuter,

   157

		lengthof(_airport_depots_commuter),

   158

		5, 4, 4,

   159

		0,

   160

		4

   161

	);

   162

   163

	HeliDepot = new AirportFTAClass(

   164

		_airport_moving_data_helidepot,

   165

		NULL,

   166

		_airport_helipad_helidepot,

   167

		_airport_entries_helidepot,

   168

		AirportFTAClass::HELICOPTERS,

   169

		_airport_fta_helidepot,

   170

		_airport_depots_helidepot,

   171

		lengthof(_airport_depots_helidepot),

   172

		2, 2, 2,

   173

		0,

   174

		4

   175

	);

   176

   177

	HeliStation = new AirportFTAClass(

   178

		_airport_moving_data_helistation,

   179

		NULL,

   180

		_airport_helipad_helistation,

   181

		_airport_entries_helistation,

   182

		AirportFTAClass::HELICOPTERS,

   183

		_airport_fta_helistation,

   184

		_airport_depots_helistation,

   185

		lengthof(_airport_depots_helistation),

   186

		4, 2, 3,

   187

		0,

   188

		4

   189

	);

   190

}

   191

   192

void UnInitializeAirports()

   193

{

   194

	delete DummyAirport;

   195

	delete CountryAirport;

   196

	delete CityAirport;

   197

	delete Heliport;

   198

	delete MetropolitanAirport;

   199

	delete InternationalAirport;

   200

	delete CommuterAirport;

   201

	delete HeliDepot;

   202

	delete IntercontinentalAirport;

   203

	delete HeliStation;

   204

}

   205

   206

   207

static uint16 AirportGetNofElements(const AirportFTAbuildup *apFA);

   208

static AirportFTA *AirportBuildAutomata(uint nofelements, const AirportFTAbuildup *apFA);

   209

static byte AirportGetTerminalCount(const byte *terminals, byte *groups);

   210

static byte AirportTestFTA(uint nofelements, const AirportFTA *layout, const byte *terminals);

   211

   212

#ifdef DEBUG_AIRPORT

   213

static void AirportPrintOut(uint nofelements, const AirportFTA *layout, bool full_report);

   214

#endif

   215

   216

   217

AirportFTAClass::AirportFTAClass(

   218

	const AirportMovingData *moving_data_,

   219

	const byte *terminals_,

   220

	const byte *helipads_,

   221

	const byte *entry_points_,

   222

	Flags flags_,

   223

	const AirportFTAbuildup *apFA,

   224

	const TileIndexDiffC *depots_,

   225

	const byte nof_depots_,

   226

	uint size_x_,

   227

	uint size_y_,

   228

	byte noise_level_,

   229

	byte delta_z_,

   230

	byte catchment_

   231

) :

   232

	moving_data(moving_data_),

   233

	terminals(terminals_),

   234

	helipads(helipads_),

   235

	airport_depots(depots_),

   236

	flags(flags_),

   237

	nof_depots(nof_depots_),

   238

	nofelements(AirportGetNofElements(apFA)),

   239

	entry_points(entry_points_),

   240

	size_x(size_x_),

   241

	size_y(size_y_),

   242

	noise_level(noise_level_),

   243

	delta_z(delta_z_),

   244

	catchment(catchment_)

   245

{

   246

	byte nofterminalgroups, nofhelipadgroups;

   247

   248

	/* Set up the terminal and helipad count for an airport.

   249

	 * TODO: If there are more than 10 terminals or 4 helipads, internal variables

   250

	 * need to be changed, so don't allow that for now */

   251

	uint nofterminals = AirportGetTerminalCount(terminals, &nofterminalgroups);

   252

	if (nofterminals > MAX_TERMINALS) {

   253

		DEBUG(misc, 0, "[Ap] only a maximum of %d terminals are supported (requested %d)", MAX_TERMINALS, nofterminals);

   254

		assert(nofterminals <= MAX_TERMINALS);

   255

	}

   256

   257

	uint nofhelipads = AirportGetTerminalCount(helipads, &nofhelipadgroups);

   258

	if (nofhelipads > MAX_HELIPADS) {

   259

		DEBUG(misc, 0, "[Ap] only a maximum of %d helipads are supported (requested %d)", MAX_HELIPADS, nofhelipads);

   260

		assert(nofhelipads <= MAX_HELIPADS);

   261

	}

   262

   263

	/* Get the number of elements from the source table. We also double check this

   264

	 * with the entry point which must be within bounds and use this information

   265

	 * later on to build and validate the state machine */

   266

	for (DiagDirection i = DIAGDIR_BEGIN; i < DIAGDIR_END; i++) {

   267

		if (entry_points[i] >= nofelements) {

   268

			DEBUG(misc, 0, "[Ap] entry (%d) must be within the airport (maximum %d)", entry_points[i], nofelements);

   269

			assert(entry_points[i] < nofelements);

   270

		}

   271

	}

   272

   273

	/* Build the state machine itself */

   274

	layout = AirportBuildAutomata(nofelements, apFA);

   275

	DEBUG(misc, 6, "[Ap] #count %3d; #term %2d (%dgrp); #helipad %2d (%dgrp); entries %3d, %3d, %3d, %3d",

   276

		nofelements, nofterminals, nofterminalgroups, nofhelipads, nofhelipadgroups,

   277

		entry_points[DIAGDIR_NE], entry_points[DIAGDIR_SE], entry_points[DIAGDIR_SW], entry_points[DIAGDIR_NW]);

   278

   279

	/* Test if everything went allright. This is only a rude static test checking

   280

	 * the symantic correctness. By no means does passing the test mean that the

   281

	 * airport is working correctly or will not deadlock for example */

   282

	uint ret = AirportTestFTA(nofelements, layout, terminals);

   283

	if (ret != MAX_ELEMENTS) DEBUG(misc, 0, "[Ap] problem with element: %d", ret - 1);

   284

	assert(ret == MAX_ELEMENTS);

   285

   286

#ifdef DEBUG_AIRPORT

   287

	AirportPrintOut(nofelements, layout, DEBUG_AIRPORT);

   288

#endif

   289

}

   290

   291

   292

AirportFTAClass::~AirportFTAClass()

   293

{

   294

	for (uint i = 0; i < nofelements; i++) {

   295

		AirportFTA *current = layout[i].next;

   296

		while (current != NULL) {

   297

			AirportFTA *next = current->next;

   298

			free(current);

   299

			current = next;

   300

		};

   301

	}

   302

	free(layout);

   303

}

   304

   305

/** Get the number of elements of a source Airport state automata

   306

 * Since it is actually just a big array of AirportFTA types, we only

   307

 * know one element from the other by differing 'position' identifiers */

   308

static uint16 AirportGetNofElements(const AirportFTAbuildup *apFA)

   309

{

   310

	uint16 nofelements = 0;

   311

	int temp = apFA[0].position;

   312

   313

	for (uint i = 0; i < MAX_ELEMENTS; i++) {

   314

		if (temp != apFA[i].position) {

   315

			nofelements++;

   316

			temp = apFA[i].position;

   317

		}

   318

		if (apFA[i].position == MAX_ELEMENTS) break;

   319

	}

   320

	return nofelements;

   321

}

   322

   323

/** We calculate the terminal/helipod count based on the data passed to us

   324

 * This data (terminals) contains an index as a first element as to how many

   325

 * groups there are, and then the number of terminals for each group */

   326

static byte AirportGetTerminalCount(const byte *terminals, byte *groups)

   327

{

   328

	byte nof_terminals = 0;

   329

	*groups = 0;

   330

   331

	if (terminals != NULL) {

   332

		uint i = terminals[0];

   333

		*groups = i;

   334

		while (i-- > 0) {

   335

			terminals++;

   336

			assert(*terminals != 0); // no empty groups please

   337

			nof_terminals += *terminals;

   338

		}

   339

	}

   340

	return nof_terminals;

   341

}

   342

   343

   344

static AirportFTA *AirportBuildAutomata(uint nofelements, const AirportFTAbuildup *apFA)

   345

{

   346

	AirportFTA *FAutomata = MallocT<AirportFTA>(nofelements);

   347

	uint16 internalcounter = 0;

   348

   349

	for (uint i = 0; i < nofelements; i++) {

   350

		AirportFTA *current = &FAutomata[i];

   351

		current->position      = apFA[internalcounter].position;

   352

		current->heading       = apFA[internalcounter].heading;

   353

		current->block         = apFA[internalcounter].block;

   354

		current->next_position = apFA[internalcounter].next;

   355

   356

		/* outgoing nodes from the same position, create linked list */

   357

		while (current->position == apFA[internalcounter + 1].position) {

   358

			AirportFTA *newNode = MallocT<AirportFTA>(1);

   359

   360

			newNode->position      = apFA[internalcounter + 1].position;

   361

			newNode->heading       = apFA[internalcounter + 1].heading;

   362

			newNode->block         = apFA[internalcounter + 1].block;

   363

			newNode->next_position = apFA[internalcounter + 1].next;

   364

			/* create link */

   365

			current->next = newNode;

   366

			current = current->next;

   367

			internalcounter++;

   368

		}

   369

		current->next = NULL;

   370

		internalcounter++;

   371

	}

   372

	return FAutomata;

   373

}

   374

   375

   376

static byte AirportTestFTA(uint nofelements, const AirportFTA *layout, const byte *terminals)

   377

{

   378

	uint next_position = 0;

   379

   380

	for (uint i = 0; i < nofelements; i++) {

   381

		uint position = layout[i].position;

   382

		if (position != next_position) return i;

   383

		const AirportFTA *first = &layout[i];

   384

   385

		for (const AirportFTA *current = first; current != NULL; current = current->next) {

   386

			/* A heading must always be valid. The only exceptions are

   387

			 * - multiple choices as start, identified by a special value of 255

   388

			 * - terminal group which is identified by a special value of 255 */

   389

			if (current->heading > MAX_HEADINGS) {

   390

				if (current->heading != 255) return i;

   391

				if (current == first && current->next == NULL) return i;

   392

				if (current != first && current->next_position > terminals[0]) return i;

   393

			}

   394

   395

			/* If there is only one choice, it must be at the end */

   396

			if (current->heading == 0 && current->next != NULL) return i;

   397

			/* Obviously the elements of the linked list must have the same identifier */

   398

			if (position != current->position) return i;

   399

			/* A next position must be within bounds */

   400

			if (current->next_position >= nofelements) return i;

   401

		}

   402

		next_position++;

   403

	}

   404

	return MAX_ELEMENTS;

   405

}

   406

   407

#ifdef DEBUG_AIRPORT

   408

static const char * const _airport_heading_strings[] = {

   409

	"TO_ALL",

   410

	"HANGAR",

   411

	"TERM1",

   412

	"TERM2",

   413

	"TERM3",

   414

	"TERM4",

   415

	"TERM5",

   416

	"TERM6",

   417

	"HELIPAD1",

   418

	"HELIPAD2",

   419

	"TAKEOFF",

   420

	"STARTTAKEOFF",

   421

	"ENDTAKEOFF",

   422

	"HELITAKEOFF",

   423

	"FLYING",

   424

	"LANDING",

   425

	"ENDLANDING",

   426

	"HELILANDING",

   427

	"HELIENDLANDING",

   428

	"TERM7",

   429

	"TERM8",

   430

	"HELIPAD3",

   431

	"HELIPAD4",

   432

	"DUMMY" // extra heading for 255

   433

};

   434

   435

static void AirportPrintOut(uint nofelements, const AirportFTA *layout, bool full_report)

   436

{

   437

	if (!full_report) printf("(P = Current Position; NP = Next Position)\n");

   438

   439

	for (uint i = 0; i < nofelements; i++) {

   440

		for (const AirportFTA *current = &layout[i]; current != NULL; current = current->next) {

   441

			if (full_report) {

   442

				byte heading = (current->heading == 255) ? MAX_HEADINGS + 1 : current->heading;

   443

				printf("\tPos:%2d NPos:%2d Heading:%15s Block:%2d\n", current->position,

   444

					    current->next_position, _airport_heading_strings[heading],

   445

							FindLastBit(current->block));

   446

			} else {

   447

				printf("P:%2d NP:%2d", current->position, current->next_position);

   448

			}

   449

		}

   450

		printf("\n");

   451

	}

   452

}

   453

#endif

   454

   455

const AirportFTAClass *GetAirport(const byte airport_type)

   456

{

   457

	/* FIXME -- AircraftNextAirportPos_and_Order -> Needs something nicer, don't like this code

   458

	 * needs constant change if more airports are added */

   459

	switch (airport_type) {

   460

		default:               NOT_REACHED();

   461

		case AT_SMALL:         return CountryAirport;

   462

		case AT_LARGE:         return CityAirport;

   463

		case AT_METROPOLITAN:  return MetropolitanAirport;

   464

		case AT_HELIPORT:      return Heliport;

   465

		case AT_OILRIG:        return Oilrig;

   466

		case AT_INTERNATIONAL: return InternationalAirport;

   467

		case AT_COMMUTER:      return CommuterAirport;

   468

		case AT_HELIDEPOT:     return HeliDepot;

   469

		case AT_INTERCON:      return IntercontinentalAirport;

   470

		case AT_HELISTATION:   return HeliStation;

   471

		case AT_DUMMY:         return DummyAirport;

   472

	}

   473

}

   474

   475

   476

uint32 GetValidAirports()

   477

{

   478

	uint32 mask = 0;

   479

   480

	if (_cur_year <  1960 || _settings_game.station.always_small_airport) SetBit(mask, 0);  // small airport

   481

	if (_cur_year >= 1955) SetBit(mask, 1); // city airport

   482

	if (_cur_year >= 1963) SetBit(mask, 2); // heliport

   483

	if (_cur_year >= 1980) SetBit(mask, 3); // metropolitan airport

   484

	if (_cur_year >= 1990) SetBit(mask, 4); // international airport

   485