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

    44

		4, 3

    45

	);

    46

    47

	CityAirport = new AirportFTAClass(

    48

		_airport_moving_data_town,

    49

		_airport_terminal_city,

    50

		NULL,

    51

		19,

    52

		ALL,

    53

		_airport_fta_city,

    54

		_airport_depots_city,

    55

		lengthof(_airport_depots_city),

    56

		6, 6

    57

	);

    58

    59

	MetropolitanAirport = new AirportFTAClass(

    60

		_airport_moving_data_metropolitan,

    61

		_airport_terminal_metropolitan,

    62

		NULL,

    63

		20,

    64

		ALL,

    65

		_airport_fta_metropolitan,

    66

		_airport_depots_metropolitan,

    67

		lengthof(_airport_depots_metropolitan),

    68

		6, 6

    69

	);

    70

    71

	InternationalAirport = new AirportFTAClass(

    72

		_airport_moving_data_international,

    73

		_airport_terminal_international,

    74

		_airport_helipad_international,

    75

		37,

    76

		ALL,

    77

		_airport_fta_international,

    78

		_airport_depots_international,

    79

		lengthof(_airport_depots_international),

    80

		7, 7

    81

	);

    82

    83

	IntercontinentalAirport = new AirportFTAClass(

    84

		_airport_moving_data_intercontinental,

    85

		_airport_terminal_intercontinental,

    86

		_airport_helipad_intercontinental,

    87

		43,

    88

		ALL,

    89

		_airport_fta_intercontinental,

    90

		_airport_depots_intercontinental,

    91

		lengthof(_airport_depots_intercontinental),

    92

		9,11

    93

	);

    94

    95

	Heliport = new AirportFTAClass(

    96

		_airport_moving_data_heliport,

    97

		NULL,

    98

		_airport_helipad_heliport_oilrig,

    99

		7,

   100

		HELICOPTERS_ONLY,

   101

		_airport_fta_heliport_oilrig,

   102

		NULL,

   103

		0,

   104

		1, 1

   105

	);

   106

   107

	Oilrig = new AirportFTAClass(

   108

		_airport_moving_data_oilrig,

   109

		NULL,

   110

		_airport_helipad_heliport_oilrig,

   111

		7,

   112

		HELICOPTERS_ONLY,

   113

		_airport_fta_heliport_oilrig,

   114

		NULL,

   115

		0,

   116

		1, 1

   117

	);

   118

   119

	CommuterAirport = new AirportFTAClass(

   120

		_airport_moving_data_commuter,

   121

		_airport_terminal_commuter,

   122

		_airport_helipad_commuter,

   123

		22,

   124

		ALL,

   125

		_airport_fta_commuter,

   126

		_airport_depots_commuter,

   127

		lengthof(_airport_depots_commuter),

   128

		5,4

   129

	);

   130

   131

	HeliDepot = new AirportFTAClass(

   132

		_airport_moving_data_helidepot,

   133

		NULL,

   134

		_airport_helipad_helidepot,

   135

		4,

   136

		HELICOPTERS_ONLY,

   137

		_airport_fta_helidepot,

   138

		_airport_depots_helidepot,

   139

		lengthof(_airport_depots_helidepot),

   140

		2,2

   141

	);

   142

   143

	HeliStation = new AirportFTAClass(

   144

		_airport_moving_data_helistation,

   145

		NULL,

   146

		_airport_helipad_helistation,

   147

		25,

   148

		HELICOPTERS_ONLY,

   149

		_airport_fta_helistation,

   150

		_airport_depots_helistation,

   151

		lengthof(_airport_depots_helistation),

   152

		4,2

   153

	);

   154

}

   155

   156

void UnInitializeAirports(void)

   157

{

   158

	delete CountryAirport;

   159

	delete CityAirport;

   160

	delete Heliport;

   161

	delete MetropolitanAirport;

   162

	delete InternationalAirport;

   163

	delete CommuterAirport;

   164

	delete HeliDepot;

   165

	delete IntercontinentalAirport;

   166

	delete HeliStation;

   167

}

   168

   169

   170

static uint16 AirportGetNofElements(const AirportFTAbuildup *apFA);

   171

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

   172

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

   173

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

   174

   175

#ifdef DEBUG_AIRPORT

   176

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

   177

#endif

   178

   179

   180

AirportFTAClass::AirportFTAClass(

   181

	const AirportMovingData *moving_data_,

   182

	const byte *terminals_,

   183

	const byte *helipads_,

   184

	const byte entry_point_,

   185

	const AcceptPlanes acc_planes_,

   186

	const AirportFTAbuildup *apFA,

   187

	const TileIndexDiffC *depots_,

   188

	const byte nof_depots_,

   189

	uint size_x_,

   190

	uint size_y_

   191

) :

   192

	moving_data(moving_data_),

   193

	terminals(terminals_),

   194

	helipads(helipads_),

   195

	airport_depots(depots_),

   196

	nof_depots(nof_depots_),

   199

	size_x(size_x_),

   200

	size_y(size_y_)

   201

{

   202

	byte nofterminalgroups, nofhelipadgroups;

   203

   204

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

   205

   206

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

   207

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

   208

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

   209

	uint nofterminals = AirportGetTerminalCount(terminals, &nofterminalgroups);

   210

	if (nofterminals > MAX_TERMINALS) {

   211

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

   212

		assert(nofterminals <= MAX_TERMINALS);

   213

	}

   214

   215

	uint nofhelipads = AirportGetTerminalCount(helipads, &nofhelipadgroups);

   216

	if (nofhelipads > MAX_HELIPADS) {

   217

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

   218

		assert(nofhelipads <= MAX_HELIPADS);

   219

	}

   220

   221

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

   222

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

   223

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

   224

	if (entry_point >= nofelements) {

   225

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

   226

		assert(entry_point < nofelements);

   227

	}

   228

   229

	/* Build the state machine itself */

   230

	layout = AirportBuildAutomata(nofelements, apFA);

   231

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

   232

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

   233

   234

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

   235

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

   236

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

   237

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

   238

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

   239

	assert(ret == MAX_ELEMENTS);

   240

   241

#ifdef DEBUG_AIRPORT

   242

	AirportPrintOut(nofelements, layout, DEBUG_AIRPORT);

   243

#endif

   244

}

   245

   246

   247

AirportFTAClass::~AirportFTAClass()

   248

{

   249

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

   250

		AirportFTA *current = layout[i].next;

   251

		while (current != NULL) {

   252

			AirportFTA *next = current->next;

   253

			free(current);

   254

			current = next;

   255

		};

   256

	}

   257

	free(layout);

   258

}

   259

   260

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

   261

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

   262

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

   263

static uint16 AirportGetNofElements(const AirportFTAbuildup *apFA)

   264

{

   265

	int i;

   266

	uint16 nofelements = 0;

   267

	int temp = apFA[0].position;

   268

   269

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

   270

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

   271

			nofelements++;

   272

			temp = apFA[i].position;

   273

		}

   274

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

   275

	}

   276

	return nofelements;

   277

}

   278

   279

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

   280

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

   281

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

   282

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

   283

{

   284

	byte i;

   285

	byte nof_terminals = 0;

   286

	*groups = 0;

   287

   288

	if (terminals != NULL) {

   289

		i = terminals[0];

   290

		*groups = i;

   291

		while (i-- > 0) {

   292

			terminals++;

   293

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

   294

			nof_terminals += *terminals;

   295

		}

   296

	}

   297

	return nof_terminals;

   298

}

   299

   300

   301

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

   302

{

   303

	AirportFTA *current;

   304

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

   305

	uint16 internalcounter = 0;

   306

   307

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

   308

		current = &FAutomata[i];

   309

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

   310

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

   311

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

   312

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

   313

   314

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

   315

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

   316

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

   317

   318

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

   319

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

   320

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

   321

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

   322

			// create link

   323

			current->next = newNode;

   324

			current = current->next;

   325

			internalcounter++;

   326

		} // while

   327

		current->next = NULL;

   328

		internalcounter++;

   329

	}

   330

	return FAutomata;

   331

}

   332

   333

   334

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

   335

{

   336

	uint next_position = 0;

   337

   338

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

   339

		uint position = layout[i].position;

   340

		if (position != next_position) return i;

   341

		const AirportFTA *first = &layout[i];

   342

		const AirportFTA *current = first;

   343

   344

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

   345

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

   346

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

   347

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

   348

			if (current->heading > MAX_HEADINGS) {

   349

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

   350

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

   351

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

   352

			}

   353

   354

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

   355

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

   356

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

   357

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

   358

			/* A next position must be within bounds */

   359

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

   360

		}

   361

		next_position++;

   362

	}

   363

	return MAX_ELEMENTS;

   364

}

   365

   366

#ifdef DEBUG_AIRPORT

   367

static const char* const _airport_heading_strings[] = {

   368

	"TO_ALL",

   369

	"HANGAR",

   370

	"TERM1",

   371

	"TERM2",

   372

	"TERM3",

   373

	"TERM4",

   374

	"TERM5",

   375

	"TERM6",

   376

	"HELIPAD1",

   377

	"HELIPAD2",

   378

	"TAKEOFF",

   379

	"STARTTAKEOFF",

   380

	"ENDTAKEOFF",

   381

	"HELITAKEOFF",

   382

	"FLYING",

   383

	"LANDING",

   384

	"ENDLANDING",

   385

	"HELILANDING",

   386

	"HELIENDLANDING",

   387

	"TERM7",

   388

	"TERM8",

   389

	"HELIPAD3",

   390

	"HELIPAD4",

   391

	"DUMMY" // extra heading for 255

   392

};

   393

   394

static uint AirportBlockToString(uint32 block)

   395

{

   396

	uint i = 0;

   397

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

   398

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

   399

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

   400

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

   401

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

   402

	return i;

   403

}

   404

   405

   406

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

   407

{

   408

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

   409

   410

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

   411

		const AirportFTA *current = &layout[i];

   412

   413

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

   414

			if (full_report) {

   415

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

   416

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

   417

					    current->next_position, _airport_heading_strings[heading],

   418

							AirportBlockToString(current->block));

   419

			} else {

   420

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

   421

			}

   422

		}

   423

		printf("\n");

   424

	}

   425

}

   426

#endif

   427

   428

const AirportFTAClass *GetAirport(const byte airport_type)

   429

{

   430

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

   431

	// needs constant change if more airports are added

   432

	switch (airport_type) {

   433

		default:               NOT_REACHED();

   434

		case AT_SMALL:         return CountryAirport;

   435

		case AT_LARGE:         return CityAirport;

   436

		case AT_METROPOLITAN:  return MetropolitanAirport;

   437

		case AT_HELIPORT:      return Heliport;

   438

		case AT_OILRIG:        return Oilrig;

   439

		case AT_INTERNATIONAL: return InternationalAirport;

   440

		case AT_COMMUTER:      return CommuterAirport;

   441

		case AT_HELIDEPOT:     return HeliDepot;

   442

		case AT_INTERCON:      return IntercontinentalAirport;

   443

		case AT_HELISTATION:   return HeliStation;

   444

	}

   445

}

   446

   447

   448

uint32 GetValidAirports(void)

   449

{

   450

	uint32 bytemask = _avail_aircraft; /// sets the first 3 bytes, 0 - 2, @see AdjustAvailAircraft()

   451

   452

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

   453

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

   454

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

   455

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

   456

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

   457

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

   458

	return bytemask;

   459

}