1

/* $Id$ */

     2

     3

/** @file airport.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "debug.h"

     8

#include "map.h"

     9

#include "airport.h"

    10

#include "macros.h"

    11

#include "variables.h"

    12

#include "airport_movement.h"

    13

#include "date.h"

    14

#include "helpers.hpp"

    15

    16

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

    17

 * You should either use

    18

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

    19

 * OR

    20

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

    21

//#define DEBUG_AIRPORT false

    22

    23

static AirportFTAClass *DummyAirport;

    24

static AirportFTAClass *CountryAirport;

    25

static AirportFTAClass *CityAirport;

    26

static AirportFTAClass *Oilrig;

    27

static AirportFTAClass *Heliport;

    28

static AirportFTAClass *MetropolitanAirport;

    29

static AirportFTAClass *InternationalAirport;

    30

static AirportFTAClass *CommuterAirport;

    31

static AirportFTAClass *HeliDepot;

    32

static AirportFTAClass *IntercontinentalAirport;

    33

static AirportFTAClass *HeliStation;

    34

    35

    36

void InitializeAirports()

    37

{

    38

	DummyAirport = new AirportFTAClass(

    39

		_airport_moving_data_dummy,

    40

		NULL,

    41

		NULL,

    42

		_airport_entries_dummy,

    43

		AirportFTAClass::ALL,

    44

		_airport_fta_dummy,

    45

		NULL,

    46

		0,

    47

		0, 0,

    48

		0,

    49

		0

    50

	);

    51

    52

	CountryAirport = new AirportFTAClass(

    53

		_airport_moving_data_country,

    54

		_airport_terminal_country,

    55

		NULL,

    56

		_airport_entries_country,

    57

		AirportFTAClass::ALL | AirportFTAClass::SHORT_STRIP,

    58

		_airport_fta_country,

    59

		_airport_depots_country,

    60

		lengthof(_airport_depots_country),

    61

		4, 3,

    62

		0,

    63

		4

    64

	);

    65

    66

	CityAirport = new AirportFTAClass(

    67

		_airport_moving_data_town,

    68

		_airport_terminal_city,

    69

		NULL,

    70

		_airport_entries_city,

    71

		AirportFTAClass::ALL,

    72

		_airport_fta_city,

    73

		_airport_depots_city,

    74

		lengthof(_airport_depots_city),

    75

		6, 6,

    76

		0,

    77

		5

    78

	);

    79

    80

	MetropolitanAirport = new AirportFTAClass(

    81

		_airport_moving_data_metropolitan,

    82

		_airport_terminal_metropolitan,

    83

		NULL,

    84

		_airport_entries_metropolitan,

    85

		AirportFTAClass::ALL,

    86

		_airport_fta_metropolitan,

    87

		_airport_depots_metropolitan,

    88

		lengthof(_airport_depots_metropolitan),

    89

		6, 6,

    90

		0,

    91

		6

    92

	);

    93

    94

	InternationalAirport = new AirportFTAClass(

    95

		_airport_moving_data_international,

    96

		_airport_terminal_international,

    97

		_airport_helipad_international,

    98

		_airport_entries_international,

    99

		AirportFTAClass::ALL,

   100

		_airport_fta_international,

   101

		_airport_depots_international,

   102

		lengthof(_airport_depots_international),

   103

		7, 7,

   104

		0,

   105

		8

   106

	);

   107

   108

	IntercontinentalAirport = new AirportFTAClass(

   109

		_airport_moving_data_intercontinental,

   110

		_airport_terminal_intercontinental,

   111

		_airport_helipad_intercontinental,

   112

		_airport_entries_intercontinental,

   113

		AirportFTAClass::ALL,

   114

		_airport_fta_intercontinental,

   115

		_airport_depots_intercontinental,

   116

		lengthof(_airport_depots_intercontinental),

   117

		9, 11,

   118

		0,

   119

		10

   120

	);

   121

   122

	Heliport = new AirportFTAClass(

   123

		_airport_moving_data_heliport,

   124

		NULL,

   125

		_airport_helipad_heliport_oilrig,

   126

		_airport_entries_heliport_oilrig,

   127

		AirportFTAClass::HELICOPTERS,

   128

		_airport_fta_heliport_oilrig,

   129

		NULL,

   130

		0,

   131

		1, 1,

   132

		60,

   133

		4

   134

	);

   135

   136

	Oilrig = new AirportFTAClass(

   137

		_airport_moving_data_oilrig,

   138

		NULL,

   139

		_airport_helipad_heliport_oilrig,

   140

		_airport_entries_heliport_oilrig,

   141

		AirportFTAClass::HELICOPTERS,

   142

		_airport_fta_heliport_oilrig,

   143

		NULL,

   144

		0,

   145

		1, 1,

   146

		54,

   147

		3

   148

	);

   149

   150

	CommuterAirport = new AirportFTAClass(

   151

		_airport_moving_data_commuter,

   152

		_airport_terminal_commuter,

   153

		_airport_helipad_commuter,

   154

		_airport_entries_commuter,

   155

		AirportFTAClass::ALL | AirportFTAClass::SHORT_STRIP,

   156

		_airport_fta_commuter,

   157

		_airport_depots_commuter,

   158

		lengthof(_airport_depots_commuter),

   159

		5, 4,

   160

		0,

   161

		4

   162

	);

   163

   164

	HeliDepot = new AirportFTAClass(

   165

		_airport_moving_data_helidepot,

   166

		NULL,

   167

		_airport_helipad_helidepot,

   168

		_airport_entries_helidepot,

   169

		AirportFTAClass::HELICOPTERS,

   170

		_airport_fta_helidepot,

   171

		_airport_depots_helidepot,

   172

		lengthof(_airport_depots_helidepot),

   173

		2, 2,

   174

		0,

   175

		4

   176

	);

   177

   178

	HeliStation = new AirportFTAClass(

   179

		_airport_moving_data_helistation,

   180

		NULL,

   181

		_airport_helipad_helistation,

   182

		_airport_entries_helistation,

   183

		AirportFTAClass::HELICOPTERS,

   184

		_airport_fta_helistation,

   185

		_airport_depots_helistation,

   186

		lengthof(_airport_depots_helistation),

   187

		4, 2,

   188

		0,

   189

		4

   190

	);

   191

}

   192

   193

void UnInitializeAirports()

   194

{

   196

	delete CountryAirport;

   197

	delete CityAirport;

   198

	delete Heliport;

   199

	delete MetropolitanAirport;

   200

	delete InternationalAirport;

   201

	delete CommuterAirport;

   202

	delete HeliDepot;

   203

	delete IntercontinentalAirport;

   204

	delete HeliStation;

   205

}

   206

   207

   208

static uint16 AirportGetNofElements(const AirportFTAbuildup *apFA);

   209

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

   210

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

   211

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

   212

   213

#ifdef DEBUG_AIRPORT

   214

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

   215

#endif

   216

   217

   218

AirportFTAClass::AirportFTAClass(

   219

	const AirportMovingData *moving_data_,

   220

	const byte *terminals_,

   221

	const byte *helipads_,

   222

	const byte *entry_points_,

   223

	Flags flags_,

   224

	const AirportFTAbuildup *apFA,

   225

	const TileIndexDiffC *depots_,

   226

	const byte nof_depots_,

   227

	uint size_x_,

   228

	uint size_y_,

   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

	delta_z(delta_z_),

   243

	catchment(catchment_)

   244

{

   245

	byte nofterminalgroups, nofhelipadgroups;

   246

   247

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

   248

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

   249

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

   250

	uint nofterminals = AirportGetTerminalCount(terminals, &nofterminalgroups);

   251

	if (nofterminals > MAX_TERMINALS) {

   252

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

   253

		assert(nofterminals <= MAX_TERMINALS);

   254

	}

   255

   256

	uint nofhelipads = AirportGetTerminalCount(helipads, &nofhelipadgroups);

   257

	if (nofhelipads > MAX_HELIPADS) {

   258

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

   259

		assert(nofhelipads <= MAX_HELIPADS);

   260

	}

   261

   262

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

   263

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

   264

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

   265

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

   266

		if (entry_points[i] >= nofelements) {

   267

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

   268

			assert(entry_points[i] < nofelements);

   269

		}

   270

	}

   271

   272

	/* Build the state machine itself */

   273

	layout = AirportBuildAutomata(nofelements, apFA);

   274

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

   275

		nofelements, nofterminals, nofterminalgroups, nofhelipads, nofhelipadgroups,

   276

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

   277

   278

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

   279

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

   280

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

   281

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

   282

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

   283

	assert(ret == MAX_ELEMENTS);

   284

   285

#ifdef DEBUG_AIRPORT

   286

	AirportPrintOut(nofelements, layout, DEBUG_AIRPORT);

   287

#endif

   288

}

   289

   290

   291

AirportFTAClass::~AirportFTAClass()

   292

{

   293

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

   294

		AirportFTA *current = layout[i].next;

   295

		while (current != NULL) {

   296

			AirportFTA *next = current->next;

   297

			free(current);

   298

			current = next;

   299

		};

   300

	}

   301

	free(layout);

   302

}

   303

   304

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

   305

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

   306

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

   307

static uint16 AirportGetNofElements(const AirportFTAbuildup *apFA)

   308

{

   309

	uint16 nofelements = 0;

   310

	int temp = apFA[0].position;

   311

   312

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

   313

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

   314

			nofelements++;

   315

			temp = apFA[i].position;

   316

		}

   317

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

   318

	}

   319

	return nofelements;

   320

}

   321

   322

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

   323

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

   324

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

   325

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

   326

{

   327

	byte nof_terminals = 0;

   328

	*groups = 0;

   329

   330

	if (terminals != NULL) {

   331

		uint i = terminals[0];

   332

		*groups = i;

   333

		while (i-- > 0) {

   334

			terminals++;

   335

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

   336

			nof_terminals += *terminals;

   337

		}

   338

	}

   339

	return nof_terminals;

   340

}

   341

   342

   343

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

   344

{

   345

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

   346

	uint16 internalcounter = 0;

   347

   348

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

   349

		AirportFTA *current = &FAutomata[i];

   350

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

   351

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

   352

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

   353

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

   354

   355

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

   356

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

   357

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

   358

   359

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

   360

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

   361

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

   362

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

   363

			// create link

   364

			current->next = newNode;

   365

			current = current->next;

   366

			internalcounter++;

   367

		}

   368

		current->next = NULL;

   369

		internalcounter++;

   370

	}

   371

	return FAutomata;

   372

}

   373

   374

   375

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

   376

{

   377

	uint next_position = 0;

   378

   379

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

   380

		uint position = layout[i].position;

   381

		if (position != next_position) return i;

   382

		const AirportFTA *first = &layout[i];

   383

   384

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

   385

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

   386

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

   387

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

   388

			if (current->heading > MAX_HEADINGS) {

   389

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

   390

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

   391

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

   392

			}

   393

   394

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

   395

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

   396

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

   397

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

   398

			/* A next position must be within bounds */

   399

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

   400

		}

   401

		next_position++;

   402

	}

   403

	return MAX_ELEMENTS;

   404

}

   405

   406

#ifdef DEBUG_AIRPORT

   407

static const char* const _airport_heading_strings[] = {

   408

	"TO_ALL",

   409

	"HANGAR",

   410

	"TERM1",

   411

	"TERM2",

   412

	"TERM3",

   413

	"TERM4",

   414

	"TERM5",

   415

	"TERM6",

   416

	"HELIPAD1",

   417

	"HELIPAD2",

   418

	"TAKEOFF",

   419

	"STARTTAKEOFF",

   420

	"ENDTAKEOFF",

   421

	"HELITAKEOFF",

   422

	"FLYING",

   423

	"LANDING",

   424

	"ENDLANDING",

   425

	"HELILANDING",

   426

	"HELIENDLANDING",

   427

	"TERM7",

   428

	"TERM8",

   429

	"HELIPAD3",

   430

	"HELIPAD4",

   431

	"DUMMY" // extra heading for 255

   432

};

   433

   434

static uint AirportBlockToString(uint32 block)

   435

{

   436

	uint i = 0;

   437

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

   438

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

   439

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

   440

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

   441

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

   442

	return i;

   443

}

   444

   445

   446

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

   447

{

   448

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

   449

   450

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

   451

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

   452

			if (full_report) {

   453

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

   454

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

   455

					    current->next_position, _airport_heading_strings[heading],

   456

							AirportBlockToString(current->block));

   457

			} else {

   458

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

   459

			}

   460

		}

   461

		printf("\n");

   462

	}

   463

}

   464

#endif

   465

   466

const AirportFTAClass *GetAirport(const byte airport_type)

   467

{

   468

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

   469

	// needs constant change if more airports are added

   470

	switch (airport_type) {

   471

		default:               NOT_REACHED();

   472

		case AT_SMALL:         return CountryAirport;

   473

		case AT_LARGE:         return CityAirport;

   474

		case AT_METROPOLITAN:  return MetropolitanAirport;

   475

		case AT_HELIPORT:      return Heliport;

   476

		case AT_OILRIG:        return Oilrig;

   477

		case AT_INTERNATIONAL: return InternationalAirport;

   478

		case AT_COMMUTER:      return CommuterAirport;

   479

		case AT_HELIDEPOT:     return HeliDepot;

   480

		case AT_INTERCON:      return IntercontinentalAirport;

   481

		case AT_HELISTATION:   return HeliStation;

   482

		case AT_DUMMY:         return DummyAirport;

   483

	}

   484

}

   485

   486