1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "debug.h"

     6

#include "map.h"

     7

#include "airport.h"

     8

#include "macros.h"

     9

#include "variables.h"

    10

#include "airport_movement.h"

    11

#include "date.h"

    12

#include "helpers.hpp"

    13

    14

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

    15

 * You should either use

    16

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

    17

 * OR

    18

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

    19

//#define DEBUG_AIRPORT false

    20

    21

static AirportFTAClass *CountryAirport;

    22

static AirportFTAClass *CityAirport;

    23

static AirportFTAClass *Oilrig;

    24

static AirportFTAClass *Heliport;

    25

static AirportFTAClass *MetropolitanAirport;

    26

static AirportFTAClass *InternationalAirport;

    27

static AirportFTAClass *CommuterAirport;

    28

static AirportFTAClass *HeliDepot;

    29

static AirportFTAClass *IntercontinentalAirport;

    30

static AirportFTAClass *HeliStation;

    31

    32

    33

void InitializeAirports(void)

    34

{

    35

	CountryAirport = new AirportFTAClass(

    36

		_airport_moving_data_country,

    37

		_airport_terminal_country,

    38

		NULL,

    39

		_airport_entries_country,

    40

		AirportFTAClass::ALL | AirportFTAClass::SHORT_STRIP,

    41

		_airport_fta_country,

    42

		_airport_depots_country,

    43

		lengthof(_airport_depots_country),

    44

		4, 3,

    45

		0,

    46

		4

    47

	);

    48

    49

	CityAirport = new AirportFTAClass(

    50

		_airport_moving_data_town,

    51

		_airport_terminal_city,

    52

		NULL,

    53

		_airport_entries_city,

    54

		AirportFTAClass::ALL,

    55

		_airport_fta_city,

    56

		_airport_depots_city,

    57

		lengthof(_airport_depots_city),

    58

		6, 6,

    59

		0,

    60

		5

    61

	);

    62

    63

	MetropolitanAirport = new AirportFTAClass(

    64

		_airport_moving_data_metropolitan,

    65

		_airport_terminal_metropolitan,

    66

		NULL,

    67

		_airport_entries_metropolitan,

    68

		AirportFTAClass::ALL,

    69

		_airport_fta_metropolitan,

    70

		_airport_depots_metropolitan,

    71

		lengthof(_airport_depots_metropolitan),

    72

		6, 6,

    73

		0,

    74

		6

    75

	);

    76

    77

	InternationalAirport = new AirportFTAClass(

    78

		_airport_moving_data_international,

    79

		_airport_terminal_international,

    80

		_airport_helipad_international,

    81

		_airport_entries_international,

    82

		AirportFTAClass::ALL,

    83

		_airport_fta_international,

    84

		_airport_depots_international,

    85

		lengthof(_airport_depots_international),

    86

		7, 7,

    87

		0,

    88

		8

    89

	);

    90

    91

	IntercontinentalAirport = new AirportFTAClass(

    92

		_airport_moving_data_intercontinental,

    93

		_airport_terminal_intercontinental,

    94

		_airport_helipad_intercontinental,

    95

		_airport_entries_intercontinental,

    96

		AirportFTAClass::ALL,

    97

		_airport_fta_intercontinental,

    98

		_airport_depots_intercontinental,

    99

		lengthof(_airport_depots_intercontinental),

   100

		9, 11,

   101

		0,

   102

		10

   103

	);

   104

   105

	Heliport = new AirportFTAClass(

   106

		_airport_moving_data_heliport,

   107

		NULL,

   108

		_airport_helipad_heliport_oilrig,

   109

		_airport_entries_heliport_oilrig,

   110

		AirportFTAClass::HELICOPTERS,

   111

		_airport_fta_heliport_oilrig,

   112

		NULL,

   113

		0,

   114

		1, 1,

   115

		60,

   116

		4

   117

	);

   118

   119

	Oilrig = new AirportFTAClass(

   120

		_airport_moving_data_oilrig,

   121

		NULL,

   122

		_airport_helipad_heliport_oilrig,

   123

		_airport_entries_heliport_oilrig,

   124

		AirportFTAClass::HELICOPTERS,

   125

		_airport_fta_heliport_oilrig,

   126

		NULL,

   127

		0,

   128

		1, 1,

   129

		54,

   130

		3

   131

	);

   132

   133

	CommuterAirport = new AirportFTAClass(

   134

		_airport_moving_data_commuter,

   135

		_airport_terminal_commuter,

   136

		_airport_helipad_commuter,

   137

		_airport_entries_commuter,

   138

		AirportFTAClass::ALL | AirportFTAClass::SHORT_STRIP,

   139

		_airport_fta_commuter,

   140

		_airport_depots_commuter,

   141

		lengthof(_airport_depots_commuter),

   142

		5, 4,

   143

		0,

   144

		4

   145

	);

   146

   147

	HeliDepot = new AirportFTAClass(

   148

		_airport_moving_data_helidepot,

   149

		NULL,

   150

		_airport_helipad_helidepot,

   151

		_airport_entries_helidepot,

   152

		AirportFTAClass::HELICOPTERS,

   153

		_airport_fta_helidepot,

   154

		_airport_depots_helidepot,

   155

		lengthof(_airport_depots_helidepot),

   156

		2, 2,

   157

		0,

   158

		4

   159

	);

   160

   161

	HeliStation = new AirportFTAClass(

   162

		_airport_moving_data_helistation,

   163

		NULL,

   164

		_airport_helipad_helistation,

   165

		_airport_entries_helistation,

   166

		AirportFTAClass::HELICOPTERS,

   167

		_airport_fta_helistation,

   168

		_airport_depots_helistation,

   169

		lengthof(_airport_depots_helistation),

   170

		4, 2,

   171

		0,

   172

		4

   173

	);

   174

}

   175

   176

void UnInitializeAirports(void)

   177

{

   178

	delete CountryAirport;

   179

	delete CityAirport;

   180

	delete Heliport;

   181

	delete MetropolitanAirport;

   182

	delete InternationalAirport;

   183

	delete CommuterAirport;

   184

	delete HeliDepot;

   185

	delete IntercontinentalAirport;

   186

	delete HeliStation;

   187

}

   188

   189

   190

static uint16 AirportGetNofElements(const AirportFTAbuildup *apFA);

   191

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

   192

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

   193

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

   194

   195

#ifdef DEBUG_AIRPORT

   196

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

   197

#endif

   198

   199

   200

AirportFTAClass::AirportFTAClass(

   201

	const AirportMovingData *moving_data_,

   202

	const byte *terminals_,

   203

	const byte *helipads_,

   204

	const byte *entry_points_,

   205

	Flags flags_,

   206

	const AirportFTAbuildup *apFA,

   207

	const TileIndexDiffC *depots_,

   208

	const byte nof_depots_,

   209

	uint size_x_,

   210

	uint size_y_,

   211

	byte delta_z_,

   212

	byte catchment_

   213

) :

   214

	moving_data(moving_data_),

   215

	terminals(terminals_),

   216

	helipads(helipads_),

   217

	airport_depots(depots_),

   218

	flags(flags_),

   219

	nof_depots(nof_depots_),

   220

	nofelements(AirportGetNofElements(apFA)),

   221

	entry_points(entry_points_),

   222

	size_x(size_x_),

   223

	size_y(size_y_),

   224

	delta_z(delta_z_),

   225

	catchment(catchment_)

   226

{

   227

	byte nofterminalgroups, nofhelipadgroups;

   228

   229

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

   230

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

   231

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

   232

	uint nofterminals = AirportGetTerminalCount(terminals, &nofterminalgroups);

   233

	if (nofterminals > MAX_TERMINALS) {

   234

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

   235

		assert(nofterminals <= MAX_TERMINALS);

   236

	}

   237

   238

	uint nofhelipads = AirportGetTerminalCount(helipads, &nofhelipadgroups);

   239

	if (nofhelipads > MAX_HELIPADS) {

   240

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

   241

		assert(nofhelipads <= MAX_HELIPADS);

   242

	}

   243

   244

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

   245

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

   246

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

   247

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

   248

		if (entry_points[i] >= nofelements) {

   249

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

   250

			assert(entry_points[i] < nofelements);

   251

		}

   252

	}

   253

   254

	/* Build the state machine itself */

   255

	layout = AirportBuildAutomata(nofelements, apFA);

   256

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

   257

		nofelements, nofterminals, nofterminalgroups, nofhelipads, nofhelipadgroups,

   258

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

   259

   260

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

   261

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

   262

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

   263

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

   264

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

   265

	assert(ret == MAX_ELEMENTS);

   266

   267

#ifdef DEBUG_AIRPORT

   268

	AirportPrintOut(nofelements, layout, DEBUG_AIRPORT);

   269

#endif

   270

}

   271

   272

   273

AirportFTAClass::~AirportFTAClass()

   274

{

   275

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

   276

		AirportFTA *current = layout[i].next;

   277

		while (current != NULL) {

   278

			AirportFTA *next = current->next;

   279

			free(current);

   280

			current = next;

   281

		};

   282

	}

   283

	free(layout);

   284

}

   285

   286

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

   287

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

   288

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

   289

static uint16 AirportGetNofElements(const AirportFTAbuildup *apFA)

   290

{

   291

	int i;

   292

	uint16 nofelements = 0;

   293

	int temp = apFA[0].position;

   294

   295

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

   296

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

   297

			nofelements++;

   298

			temp = apFA[i].position;

   299

		}

   300

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

   301

	}

   302

	return nofelements;

   303

}

   304

   305

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

   306

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

   307

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

   308

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

   309

{

   310

	byte i;

   311

	byte nof_terminals = 0;

   312

	*groups = 0;

   313

   314

	if (terminals != NULL) {

   315

		i = terminals[0];

   316

		*groups = i;

   317

		while (i-- > 0) {

   318

			terminals++;

   319

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

   320

			nof_terminals += *terminals;

   321

		}

   322

	}

   323

	return nof_terminals;

   324

}

   325

   326

   327

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

   328

{

   329

	AirportFTA *current;

   330

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

   331

	uint16 internalcounter = 0;

   332

   333

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

   334

		current = &FAutomata[i];

   335

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

   336

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

   337

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

   338

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

   339

   340

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

   341

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

   342

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

   343

   344

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

   345

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

   346

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

   347

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

   348

			// create link

   349

			current->next = newNode;

   350

			current = current->next;

   351

			internalcounter++;

   352

		} // while

   353

		current->next = NULL;

   354

		internalcounter++;

   355

	}

   356

	return FAutomata;

   357

}

   358

   359

   360

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

   361

{

   362

	uint next_position = 0;

   363

   364

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

   365

		uint position = layout[i].position;

   366

		if (position != next_position) return i;

   367

		const AirportFTA *first = &layout[i];

   368

		const AirportFTA *current = first;

   369

   370

		for (; current != NULL; current = current->next) {

   371

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

   372

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

   373

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

   374

			if (current->heading > MAX_HEADINGS) {

   375

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

   376

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

   377

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

   378

			}

   379

   380

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

   381

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

   382

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

   383

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

   384

			/* A next position must be within bounds */

   385

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

   386

		}

   387

		next_position++;

   388

	}

   389

	return MAX_ELEMENTS;

   390

}

   391

   392

#ifdef DEBUG_AIRPORT

   393

static const char* const _airport_heading_strings[] = {

   394

	"TO_ALL",

   395

	"HANGAR",

   396

	"TERM1",

   397

	"TERM2",

   398

	"TERM3",

   399

	"TERM4",

   400

	"TERM5",

   401

	"TERM6",

   402

	"HELIPAD1",

   403

	"HELIPAD2",

   404

	"TAKEOFF",

   405

	"STARTTAKEOFF",

   406

	"ENDTAKEOFF",

   407

	"HELITAKEOFF",

   408

	"FLYING",

   409

	"LANDING",

   410

	"ENDLANDING",

   411

	"HELILANDING",

   412

	"HELIENDLANDING",

   413

	"TERM7",

   414

	"TERM8",

   415

	"HELIPAD3",

   416

	"HELIPAD4",

   417

	"DUMMY" // extra heading for 255

   418

};

   419

   420

static uint AirportBlockToString(uint32 block)

   421

{

   422

	uint i = 0;

   423

	if (block & 0xffff0000) { block >>= 16; i += 16; }

   424

	if (block & 0x0000ff00) { block >>=  8; i +=  8; }

   425

	if (block & 0x000000f0) { block >>=  4; i +=  4; }

   426

	if (block & 0x0000000c) { block >>=  2; i +=  2; }

   427

	if (block & 0x00000002) { i += 1; }

   428

	return i;

   429

}

   430

   431

   432

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

   433

{

   434

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

   435

   436

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

   437

		const AirportFTA *current = &layout[i];

   438

   439

		for (; current != NULL; current = current->next) {

   440

			if (full_report) {

   441

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

   442

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

   443

					    current->next_position, _airport_heading_strings[heading],

   444

							AirportBlockToString(current->block));

   445

			} else {

   446

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

   447

			}

   448

		}

   449

		printf("\n");

   450

	}

   451

}

   452

#endif

   453

   454

const AirportFTAClass *GetAirport(const byte airport_type)

   455

{

   456

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

   457

	// needs constant change if more airports are added

   458

	switch (airport_type) {

   459

		default:               NOT_REACHED();

   460

		case AT_SMALL:         return CountryAirport;

   461

		case AT_LARGE:         return CityAirport;

   462

		case AT_METROPOLITAN:  return MetropolitanAirport;

   463

		case AT_HELIPORT:      return Heliport;

   464

		case AT_OILRIG:        return Oilrig;

   465

		case AT_INTERNATIONAL: return InternationalAirport;

   466

		case AT_COMMUTER:      return CommuterAirport;

   467

		case AT_HELIDEPOT:     return HeliDepot;

   468

		case AT_INTERCON:      return IntercontinentalAirport;

   469

		case AT_HELISTATION:   return HeliStation;

   470

	}

   471

}

   472

   473

   474

uint32 GetValidAirports(void)

   475

{

   476

	uint32 mask = 0;

   477

   478

	if (_cur_year <  1960 || _patches.always_small_airport) SETBIT(mask, 0);  // small airport

   479

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

   480

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

   481

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

   482

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

   483

	if (_cur_year >= 1983) SETBIT(mask, 5); // commuter airport

   484

	if (_cur_year >= 1976) SETBIT(mask, 6); // helidepot

   485

	if (_cur_year >= 2002) SETBIT(mask, 7); // intercontinental airport

   486

	if (_cur_year >= 1980) SETBIT(mask, 8); // helistation