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

    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

{

    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

{

   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 delta_z_,

   229

	byte catchment_

   230

) :

   231

	moving_data(moving_data_),

   232

	terminals(terminals_),

   233

	helipads(helipads_),

   234

	airport_depots(depots_),

   235

	flags(flags_),

   236

	nof_depots(nof_depots_),

   237

	nofelements(AirportGetNofElements(apFA)),

   238

	entry_points(entry_points_),

   239

	size_x(size_x_),

   240

	size_y(size_y_),

   241

	delta_z(delta_z_),

   242

	catchment(catchment_)

   243

{

   244

	byte nofterminalgroups, nofhelipadgroups;

   245

   246

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

   247

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

   248

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

   249

	uint nofterminals = AirportGetTerminalCount(terminals, &nofterminalgroups);

   250

	if (nofterminals > MAX_TERMINALS) {

   251

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

   252

		assert(nofterminals <= MAX_TERMINALS);

   253

	}

   254

   255

	uint nofhelipads = AirportGetTerminalCount(helipads, &nofhelipadgroups);

   256

	if (nofhelipads > MAX_HELIPADS) {

   257

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

   258

		assert(nofhelipads <= MAX_HELIPADS);

   259

	}

   260

   261

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

   262

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

   263

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

   264

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

   265

		if (entry_points[i] >= nofelements) {

   266

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

   267

			assert(entry_points[i] < nofelements);

   268

		}

   269

	}

   270

   271

	/* Build the state machine itself */

   272

	layout = AirportBuildAutomata(nofelements, apFA);

   273

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

   274

		nofelements, nofterminals, nofterminalgroups, nofhelipads, nofhelipadgroups,

   275

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

   276

   277

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

   278

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

   279

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

   280

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

   281

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

   282

	assert(ret == MAX_ELEMENTS);

   283

   284

#ifdef DEBUG_AIRPORT

   285

	AirportPrintOut(nofelements, layout, DEBUG_AIRPORT);

   286

#endif

   287

}

   288

   289

   290

AirportFTAClass::~AirportFTAClass()

   291

{

   292

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

   293

		AirportFTA *current = layout[i].next;

   294

		while (current != NULL) {

   295

			AirportFTA *next = current->next;

   296

			free(current);

   297

			current = next;

   298

		};

   299

	}

   300

	free(layout);

   301

}

   302

   303

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

   304

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

   305

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

   306

static uint16 AirportGetNofElements(const AirportFTAbuildup *apFA)

   307

{

   308

	uint16 nofelements = 0;

   309

	int temp = apFA[0].position;

   310

   311

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

   312

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

   313

			nofelements++;

   314

			temp = apFA[i].position;

   315

		}

   316

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

   317

	}

   318

	return nofelements;

   319

}

   320

   321

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

   322

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

   323

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

   324

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

   325

{

   326

	byte nof_terminals = 0;

   327

	*groups = 0;

   328

   329

	if (terminals != NULL) {

   330

		uint i = terminals[0];

   331

		*groups = i;

   332

		while (i-- > 0) {

   333

			terminals++;

   334

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

   335

			nof_terminals += *terminals;

   336

		}

   337

	}

   338

	return nof_terminals;

   339

}

   340

   341

   342

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

   343

{

   344

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

   345

	uint16 internalcounter = 0;

   346

   347

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

   348

		AirportFTA *current = &FAutomata[i];

   349

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

   350

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

   351

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

   352

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

   353

   354

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

   355

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

   356

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

   357

   358

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

   359

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

   360

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

   361

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

   362

			// create link

   363

			current->next = newNode;

   364

			current = current->next;

   365

			internalcounter++;

   366

		}

   367

		current->next = NULL;

   368

		internalcounter++;

   369

	}

   370

	return FAutomata;

   371

}

   372

   373

   374

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

   375

{

   376

	uint next_position = 0;

   377

   378

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

   379

		uint position = layout[i].position;

   380

		if (position != next_position) return i;

   381

		const AirportFTA *first = &layout[i];

   382

   383

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

   384

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

   385

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

   386

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

   387

			if (current->heading > MAX_HEADINGS) {

   388

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

   389

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

   390

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

   391

			}

   392

   393

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

   394

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

   395

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

   396

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

   397

			/* A next position must be within bounds */

   398

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

   399

		}

   400

		next_position++;

   401

	}

   402

	return MAX_ELEMENTS;

   403

}

   404

   405

#ifdef DEBUG_AIRPORT

   406

static const char* const _airport_heading_strings[] = {

   407

	"TO_ALL",

   408

	"HANGAR",

   409

	"TERM1",

   410

	"TERM2",

   411

	"TERM3",

   412

	"TERM4",

   413

	"TERM5",

   414

	"TERM6",

   415

	"HELIPAD1",

   416

	"HELIPAD2",

   417

	"TAKEOFF",

   418

	"STARTTAKEOFF",

   419

	"ENDTAKEOFF",

   420

	"HELITAKEOFF",

   421

	"FLYING",

   422

	"LANDING",

   423

	"ENDLANDING",

   424

	"HELILANDING",

   425

	"HELIENDLANDING",

   426

	"TERM7",

   427

	"TERM8",

   428

	"HELIPAD3",

   429

	"HELIPAD4",

   430

	"DUMMY" // extra heading for 255

   431

};

   432

   433

static uint AirportBlockToString(uint32 block)

   434

{

   435

	uint i = 0;

   436

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

   437

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

   438

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

   439

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

   440

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

   441

	return i;

   442

}

   443

   444

   445

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

   446

{

   447

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

   448

   449

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

   450

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

   451

			if (full_report) {

   452

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

   453

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

   454

					    current->next_position, _airport_heading_strings[heading],

   455

							AirportBlockToString(current->block));

   456

			} else {

   457

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

   458

			}

   459

		}

   460

		printf("\n");

   461

	}

   462

}

   463

#endif

   464

   465

const AirportFTAClass *GetAirport(const byte airport_type)

   466

{

   467

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

   468

	// needs constant change if more airports are added

   469

	switch (airport_type) {

   470

		default:               NOT_REACHED();

   471

		case AT_SMALL:         return CountryAirport;

   472

		case AT_LARGE:         return CityAirport;

   473

		case AT_METROPOLITAN:  return MetropolitanAirport;

   474

		case AT_HELIPORT:      return Heliport;

   475

		case AT_OILRIG:        return Oilrig;

   476

		case AT_INTERNATIONAL: return InternationalAirport;

   477

		case AT_COMMUTER:      return CommuterAirport;

   478

		case AT_HELIDEPOT:     return HeliDepot;

   479

		case AT_INTERCON:      return IntercontinentalAirport;

   480

		case AT_HELISTATION:   return HeliStation;

   482

	}

   483

}

   484

   485