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

		16,

    40

		ALL,

    41

		_airport_fta_country,

    42

		_airport_depots_country,

    43

		lengthof(_airport_depots_country),

    46

	);

    47

    48

	CityAirport = new AirportFTAClass(

    49

		_airport_moving_data_town,

    50

		_airport_terminal_city,

    51

		NULL,

    52

		19,

    53

		ALL,

    54

		_airport_fta_city,

    55

		_airport_depots_city,

    56

		lengthof(_airport_depots_city),

    59

	);

    60

    61

	MetropolitanAirport = new AirportFTAClass(

    62

		_airport_moving_data_metropolitan,

    63

		_airport_terminal_metropolitan,

    64

		NULL,

    65

		20,

    66

		ALL,

    67

		_airport_fta_metropolitan,

    68

		_airport_depots_metropolitan,

    69

		lengthof(_airport_depots_metropolitan),

    72

	);

    73

    74

	InternationalAirport = new AirportFTAClass(

    75

		_airport_moving_data_international,

    76

		_airport_terminal_international,

    77

		_airport_helipad_international,

    78

		37,

    79

		ALL,

    80

		_airport_fta_international,

    81

		_airport_depots_international,

    82

		lengthof(_airport_depots_international),

    85

	);

    86

    87

	IntercontinentalAirport = new AirportFTAClass(

    88

		_airport_moving_data_intercontinental,

    89

		_airport_terminal_intercontinental,

    90

		_airport_helipad_intercontinental,

    91

		43,

    92

		ALL,

    93

		_airport_fta_intercontinental,

    94

		_airport_depots_intercontinental,

    95

		lengthof(_airport_depots_intercontinental),

    98

	);

    99

   100

	Heliport = new AirportFTAClass(

   101

		_airport_moving_data_heliport,

   102

		NULL,

   103

		_airport_helipad_heliport_oilrig,

   104

		7,

   105

		HELICOPTERS_ONLY,

   106

		_airport_fta_heliport_oilrig,

   107

		NULL,

   108

		0,

   111

	);

   112

   113

	Oilrig = new AirportFTAClass(

   114

		_airport_moving_data_oilrig,

   115

		NULL,

   116

		_airport_helipad_heliport_oilrig,

   117

		7,

   118

		HELICOPTERS_ONLY,

   119

		_airport_fta_heliport_oilrig,

   120

		NULL,

   121

		0,

   124

	);

   125

   126

	CommuterAirport = new AirportFTAClass(

   127

		_airport_moving_data_commuter,

   128

		_airport_terminal_commuter,

   129

		_airport_helipad_commuter,

   130

		22,

   131

		ALL,

   132

		_airport_fta_commuter,

   133

		_airport_depots_commuter,

   134

		lengthof(_airport_depots_commuter),

   137

	);

   138

   139

	HeliDepot = new AirportFTAClass(

   140

		_airport_moving_data_helidepot,

   141

		NULL,

   142

		_airport_helipad_helidepot,

   143

		4,

   144

		HELICOPTERS_ONLY,

   145

		_airport_fta_helidepot,

   146

		_airport_depots_helidepot,

   147

		lengthof(_airport_depots_helidepot),

   150

	);

   151

   152

	HeliStation = new AirportFTAClass(

   153

		_airport_moving_data_helistation,

   154

		NULL,

   155

		_airport_helipad_helistation,

   156

		25,

   157

		HELICOPTERS_ONLY,

   158

		_airport_fta_helistation,

   159

		_airport_depots_helistation,

   160

		lengthof(_airport_depots_helistation),

   163

	);

   164

}

   165

   166

void UnInitializeAirports(void)

   167

{

   168

	delete CountryAirport;

   169

	delete CityAirport;

   170

	delete Heliport;

   171

	delete MetropolitanAirport;

   172

	delete InternationalAirport;

   173

	delete CommuterAirport;

   174

	delete HeliDepot;

   175

	delete IntercontinentalAirport;

   176

	delete HeliStation;

   177

}

   178

   179

   180

static uint16 AirportGetNofElements(const AirportFTAbuildup *apFA);

   181

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

   182

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

   183

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

   184

   185

#ifdef DEBUG_AIRPORT

   186

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

   187

#endif

   188

   189

   190

AirportFTAClass::AirportFTAClass(

   191

	const AirportMovingData *moving_data_,

   192

	const byte *terminals_,

   193

	const byte *helipads_,

   194

	const byte entry_point_,

   195

	const AcceptPlanes acc_planes_,

   196

	const AirportFTAbuildup *apFA,

   197

	const TileIndexDiffC *depots_,

   198

	const byte nof_depots_,

   199

	uint size_x_,

   202

) :

   203

	moving_data(moving_data_),

   204

	terminals(terminals_),

   205

	helipads(helipads_),

   206

	airport_depots(depots_),

   207

	nof_depots(nof_depots_),

   208

	nofelements(AirportGetNofElements(apFA)),

   209

	entry_point(entry_point_),

   210

	size_x(size_x_),

   213

{

   214

	byte nofterminalgroups, nofhelipadgroups;

   215

   216

	acc_planes = acc_planes_; // XXX TinyEnumT has no initialisation, only assignment

   217

   218

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

   219

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

   220

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

   221

	uint nofterminals = AirportGetTerminalCount(terminals, &nofterminalgroups);

   222

	if (nofterminals > MAX_TERMINALS) {

   223

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

   224

		assert(nofterminals <= MAX_TERMINALS);

   225

	}

   226

   227

	uint nofhelipads = AirportGetTerminalCount(helipads, &nofhelipadgroups);

   228

	if (nofhelipads > MAX_HELIPADS) {

   229

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

   230

		assert(nofhelipads <= MAX_HELIPADS);

   231

	}

   232

   233

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

   234

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

   235

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

   236

	if (entry_point >= nofelements) {

   237

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

   238

		assert(entry_point < nofelements);

   239

	}

   240

   241

	/* Build the state machine itself */

   242

	layout = AirportBuildAutomata(nofelements, apFA);

   243

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

   244

		nofelements, nofterminals, nofterminalgroups, nofhelipads, nofhelipadgroups, entry_point);

   245

   246

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

   247

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

   248

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

   249

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

   250

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

   251

	assert(ret == MAX_ELEMENTS);

   252

   253

#ifdef DEBUG_AIRPORT

   254

	AirportPrintOut(nofelements, layout, DEBUG_AIRPORT);

   255

#endif

   256

}

   257

   258

   259

AirportFTAClass::~AirportFTAClass()

   260

{

   261

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

   262

		AirportFTA *current = layout[i].next;

   263

		while (current != NULL) {

   264

			AirportFTA *next = current->next;

   265

			free(current);

   266

			current = next;

   267

		};

   268

	}

   269

	free(layout);

   270

}

   271

   272

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

   273

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

   274

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

   275

static uint16 AirportGetNofElements(const AirportFTAbuildup *apFA)

   276

{

   277

	int i;

   278

	uint16 nofelements = 0;

   279

	int temp = apFA[0].position;

   280

   281

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

   282

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

   283

			nofelements++;

   284

			temp = apFA[i].position;

   285

		}

   286

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

   287

	}

   288

	return nofelements;

   289

}

   290

   291

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

   292

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

   293

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

   294

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

   295

{

   296

	byte i;

   297

	byte nof_terminals = 0;

   298

	*groups = 0;

   299

   300

	if (terminals != NULL) {

   301

		i = terminals[0];

   302

		*groups = i;

   303

		while (i-- > 0) {

   304

			terminals++;

   305

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

   306

			nof_terminals += *terminals;

   307

		}

   308

	}

   309

	return nof_terminals;

   310

}

   311

   312

   313

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

   314

{

   315

	AirportFTA *current;

   316

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

   317

	uint16 internalcounter = 0;

   318

   319

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

   320

		current = &FAutomata[i];

   321

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

   322

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

   323

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

   324

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

   325

   326

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

   327

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

   328

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

   329

   330

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

   331

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

   332

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

   333

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

   334

			// create link

   335

			current->next = newNode;

   336

			current = current->next;

   337

			internalcounter++;

   338

		} // while

   339

		current->next = NULL;

   340

		internalcounter++;

   341

	}

   342

	return FAutomata;

   343

}

   344

   345

   346

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

   347

{

   348

	uint next_position = 0;

   349

   350

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

   351

		uint position = layout[i].position;

   352

		if (position != next_position) return i;

   353

		const AirportFTA *first = &layout[i];

   354

		const AirportFTA *current = first;

   355

   356

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

   357

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

   358

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

   359

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

   360

			if (current->heading > MAX_HEADINGS) {

   361

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

   362

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

   363

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

   364

			}

   365

   366

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

   367

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

   368

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

   369

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

   370

			/* A next position must be within bounds */

   371

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

   372

		}

   373

		next_position++;

   374

	}

   375

	return MAX_ELEMENTS;

   376

}

   377

   378

#ifdef DEBUG_AIRPORT

   379

static const char* const _airport_heading_strings[] = {

   380

	"TO_ALL",

   381

	"HANGAR",

   382

	"TERM1",

   383

	"TERM2",

   384

	"TERM3",

   385

	"TERM4",

   386

	"TERM5",

   387

	"TERM6",

   388

	"HELIPAD1",

   389

	"HELIPAD2",

   390

	"TAKEOFF",

   391

	"STARTTAKEOFF",

   392

	"ENDTAKEOFF",

   393

	"HELITAKEOFF",

   394

	"FLYING",

   395

	"LANDING",

   396

	"ENDLANDING",

   397

	"HELILANDING",

   398

	"HELIENDLANDING",

   399

	"TERM7",

   400

	"TERM8",

   401

	"HELIPAD3",

   402

	"HELIPAD4",

   403

	"DUMMY" // extra heading for 255

   404

};

   405

   406

static uint AirportBlockToString(uint32 block)

   407

{

   408

	uint i = 0;

   409

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

   410

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

   411

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

   412

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

   413

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

   414

	return i;

   415

}

   416

   417

   418

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

   419

{

   420

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

   421

   422

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

   423

		const AirportFTA *current = &layout[i];

   424

   425

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

   426

			if (full_report) {

   427

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

   428

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

   429

					    current->next_position, _airport_heading_strings[heading],

   430

							AirportBlockToString(current->block));

   431

			} else {

   432

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

   433

			}

   434

		}

   435

		printf("\n");

   436

	}

   437

}

   438

#endif

   439

   440

const AirportFTAClass *GetAirport(const byte airport_type)

   441

{

   442

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

   443

	// needs constant change if more airports are added

   444

	switch (airport_type) {

   445

		default:               NOT_REACHED();

   446

		case AT_SMALL:         return CountryAirport;

   447

		case AT_LARGE:         return CityAirport;

   448

		case AT_METROPOLITAN:  return MetropolitanAirport;

   449

		case AT_HELIPORT:      return Heliport;

   450

		case AT_OILRIG:        return Oilrig;

   451

		case AT_INTERNATIONAL: return InternationalAirport;

   452

		case AT_COMMUTER:      return CommuterAirport;

   453

		case AT_HELIDEPOT:     return HeliDepot;

   454

		case AT_INTERCON:      return IntercontinentalAirport;

   455

		case AT_HELISTATION:   return HeliStation;

   456

	}

   457

}

   458

   459

   460

uint32 GetValidAirports(void)

   461

{

   462

	uint32 mask = 0;

   463

   464

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

   465

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

   466

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

   467

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

   468

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

   469

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

   470

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

   471

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

   472

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

   473

	return mask;

   474

}