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

static void AirportFTAClass_Constructor(AirportFTAClass *apc,

    33

	const byte *terminals, const byte *helipads,

    34

	const byte entry_point,  const AcceptPlanes acc_planes,

    35

	const AirportFTAbuildup *apFA,

    36

	const TileIndexDiffC *depots, const byte nof_depots,

    37

	uint size_x, uint size_y

    38

);

    39

static void AirportFTAClass_Destructor(AirportFTAClass *apc);

    40

    41

static uint16 AirportGetNofElements(const AirportFTAbuildup *apFA);

    42

static void AirportBuildAutomata(AirportFTAClass *apc, const AirportFTAbuildup *apFA);

    43

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

    44

static byte AirportTestFTA(const AirportFTAClass *apc);

    45

    46

#ifdef DEBUG_AIRPORT

    47

static void AirportPrintOut(const AirportFTAClass *apc, bool full_report);

    48

#endif /* DEBUG_AIRPORT */

    49

    50

void InitializeAirports(void)

    51

{

    52

	// country airport

    53

	MallocT(&CountryAirport, 1);

    54

    55

	AirportFTAClass_Constructor(

    56

		CountryAirport,

    57

		_airport_terminal_country,

    58

		NULL,

    59

		16,

    60

		ALL,

    61

		_airport_fta_country,

    62

		_airport_depots_country,

    63

		lengthof(_airport_depots_country),

    64

		4, 3

    65

	);

    66

    67

	// city airport

    68

	MallocT(&CityAirport, 1);

    69

    70

	AirportFTAClass_Constructor(

    71

		CityAirport,

    72

		_airport_terminal_city,

    73

		NULL,

    74

		19,

    75

		ALL,

    76

		_airport_fta_city,

    77

		_airport_depots_city,

    78

		lengthof(_airport_depots_city),

    79

		6, 6

    80

	);

    81

    82

	// metropolitan airport

    83

	MallocT(&MetropolitanAirport, 1);

    84

    85

	AirportFTAClass_Constructor(

    86

		MetropolitanAirport,

    87

		_airport_terminal_metropolitan,

    88

		NULL,

    89

		20,

    90

		ALL,

    91

		_airport_fta_metropolitan,

    92

		_airport_depots_metropolitan,

    93

		lengthof(_airport_depots_metropolitan),

    94

		6, 6

    95

	);

    96

    97

	// international airport

    98

	MallocT(&InternationalAirport, 1);

    99

   100

	AirportFTAClass_Constructor(

   101

		InternationalAirport,

   102

		_airport_terminal_international,

   103

		_airport_helipad_international,

   104

		37,

   105

		ALL,

   106

		_airport_fta_international,

   107

		_airport_depots_international,

   108

		lengthof(_airport_depots_international),

   109

		7, 7

   110

	);

   111

   112

	// intercontintental airport

   113

	MallocT(&IntercontinentalAirport, 1);

   114

   115

	AirportFTAClass_Constructor(

   116

		IntercontinentalAirport,

   117

		_airport_terminal_intercontinental,

   118

		_airport_helipad_intercontinental,

   119

		43,

   120

		ALL,

   121

		_airport_fta_intercontinental,

   122

		_airport_depots_intercontinental,

   123

		lengthof(_airport_depots_intercontinental),

   124

		9,11

   125

	);

   126

   127

	// heliport, oilrig

   128

	MallocT(&Heliport, 1);

   129

   130

	AirportFTAClass_Constructor(

   131

		Heliport,

   132

		NULL,

   133

		_airport_helipad_heliport_oilrig,

   134

		7,

   135

		HELICOPTERS_ONLY,

   136

		_airport_fta_heliport_oilrig,

   137

		NULL,

   138

		0,

   139

		1, 1

   140

	);

   141

   142

	Oilrig = Heliport;  // exactly the same structure for heliport/oilrig, so share state machine

   143

   144

	// commuter airport

   145

	MallocT(&CommuterAirport, 1);

   146

   147

	AirportFTAClass_Constructor(

   148

		CommuterAirport,

   149

		_airport_terminal_commuter,

   150

		_airport_helipad_commuter,

   151

		22,

   152

		ALL,

   153

		_airport_fta_commuter,

   154

		_airport_depots_commuter,

   155

		lengthof(_airport_depots_commuter),

   156

		5,4

   157

	);

   158

   159

	// helidepot airport

   160

	MallocT(&HeliDepot, 1);

   161

   162

	AirportFTAClass_Constructor(

   163

		HeliDepot,

   164

		NULL,

   165

		_airport_helipad_helidepot,

   166

		4,

   167

		HELICOPTERS_ONLY,

   168

		_airport_fta_helidepot,

   169

		_airport_depots_helidepot,

   170

		lengthof(_airport_depots_helidepot),

   171

		2,2

   172

	);

   173

   174

	// helistation airport

   175

	MallocT(&HeliStation, 1);

   176

   177

	AirportFTAClass_Constructor(

   178

		HeliStation,

   179

		NULL,

   180

		_airport_helipad_helistation,

   181

		25,

   182

		HELICOPTERS_ONLY,

   183

		_airport_fta_helistation,

   184

		_airport_depots_helistation,

   185

		lengthof(_airport_depots_helistation),

   186

		4,2

   187

	);

   188

   189

}

   190

   191

void UnInitializeAirports(void)

   192

{

   193

	AirportFTAClass_Destructor(CountryAirport);

   194

	AirportFTAClass_Destructor(CityAirport);

   195

	AirportFTAClass_Destructor(Heliport);

   196

	AirportFTAClass_Destructor(MetropolitanAirport);

   197

	AirportFTAClass_Destructor(InternationalAirport);

   198

	AirportFTAClass_Destructor(CommuterAirport);

   199

	AirportFTAClass_Destructor(HeliDepot);

   200

	AirportFTAClass_Destructor(IntercontinentalAirport);

   201

	AirportFTAClass_Destructor(HeliStation);

   202

}

   203

   204

static void AirportFTAClass_Constructor(AirportFTAClass *apc,

   205

	const byte *terminals, const byte *helipads,

   206

	const byte entry_point, const AcceptPlanes acc_planes,

   207

	const AirportFTAbuildup *apFA,

   208

	const TileIndexDiffC *depots, const byte nof_depots,

   209

	uint size_x, uint size_y

   210

)

   211

{

   212

	byte nofterminals, nofhelipads;

   213

	byte nofterminalgroups, nofhelipadgroups;

   214

   215

	apc->size_x = size_x;

   216

	apc->size_y = size_y;

   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

	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

	apc->terminals = terminals;

   227

   228

	nofhelipads = AirportGetTerminalCount(helipads, &nofhelipadgroups);

   229

	if (nofhelipads > MAX_HELIPADS) {

   230

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

   231

		assert(nofhelipads <= MAX_HELIPADS);

   232

	}

   233

	apc->helipads = helipads;

   234

   235

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

   236

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

   237

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

   238

	apc->nofelements = AirportGetNofElements(apFA);

   239

	if (entry_point >= apc->nofelements) {

   240

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

   241

		assert(entry_point < apc->nofelements);

   242

	}

   243

   244

	apc->acc_planes     = acc_planes;

   245

	apc->entry_point    = entry_point;

   246

	apc->airport_depots = depots;

   247

	apc->nof_depots     = nof_depots;

   248

   249

	/* Build the state machine itself */

   250

	AirportBuildAutomata(apc, apFA);

   251

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

   252

		apc->nofelements, nofterminals, nofterminalgroups, nofhelipads, nofhelipadgroups, apc->entry_point);

   253

   254

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

   255

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

   256

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

   257

	{ byte ret = AirportTestFTA(apc);

   258

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

   259

		assert(ret == MAX_ELEMENTS);

   260

	}

   261

   262

#ifdef DEBUG_AIRPORT

   263

	AirportPrintOut(apc, DEBUG_AIRPORT);

   264

#endif

   265

}

   266

   267

static void AirportFTAClass_Destructor(AirportFTAClass *apc)

   268

{

   269

	int i;

   270

	AirportFTA *current, *next;

   271

   272

	for (i = 0; i < apc->nofelements; i++) {

   273

		current = apc->layout[i].next;

   274

		while (current != NULL) {

   275

			next = current->next;

   276

			free(current);

   277

			current = next;

   278

		};

   279

	}

   280

	free(apc->layout);

   281

	free(apc);

   282

}

   283

   284

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

   285

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

   286

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

   287

static uint16 AirportGetNofElements(const AirportFTAbuildup *apFA)

   288

{

   289

	int i;

   290

	uint16 nofelements = 0;

   291

	int temp = apFA[0].position;

   292

   293

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

   294

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

   295

			nofelements++;

   296

			temp = apFA[i].position;

   297

		}

   298

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

   299

	}

   300

	return nofelements;

   301

}

   302

   303

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

   304

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

   305

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

   306

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

   307

{

   308

	byte i;

   309

	byte nof_terminals = 0;

   310

	*groups = 0;

   311

   312

	if (terminals != NULL) {

   313

		i = terminals[0];

   314

		*groups = i;

   315

		while (i-- > 0) {

   316

			terminals++;

   317

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

   318

			nof_terminals += *terminals;

   319

		}

   320

	}

   321

	return nof_terminals;

   322

}

   323

   324

static void AirportBuildAutomata(AirportFTAClass *apc, const AirportFTAbuildup *apFA)

   325

{

   326

	AirportFTA *current;

   327

	AirportFTA *FAutomata;

   328

	MallocT(&FAutomata, apc->nofelements);

   329

	uint16 internalcounter = 0;

   330

	uint16 i;

   331

   332

	apc->layout = FAutomata;

   333

	for (i = 0; i < apc->nofelements; i++) {

   334

		current = &apc->layout[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;

   343

			MallocT(&newNode, 1);

   344

   345

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

   346

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

   347

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

   348

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

   349

			// create link

   350

			current->next = newNode;

   351

			current = current->next;

   352

			internalcounter++;

   353

		} // while

   354

		current->next = NULL;

   355

		internalcounter++;

   356

	}

   357

}

   358

   359

static byte AirportTestFTA(const AirportFTAClass *apc)

   360

{

   361

	byte position, i, next_position;

   362

	AirportFTA *current, *first;

   363

	next_position = 0;

   364

   365

	for (i = 0; i < apc->nofelements; i++) {

   366

		position = apc->layout[i].position;

   367

		if (position != next_position) return i;

   368

		current = first = &apc->layout[i];

   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 > apc->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 >= apc->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

static void AirportPrintOut(const AirportFTAClass *apc, bool full_report)

   432

{

   433

	uint16 i;

   434

   435

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

   436

   437

	for (i = 0; i < apc->nofelements; i++) {

   438

		AirportFTA *current = &apc->layout[i];

   439

   440

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

   441

			if (full_report) {

   442

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

   443

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

   444

					    current->next_position, _airport_heading_strings[heading],

   445

							AirportBlockToString(current->block));

   446

			} else {

   447

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

   448

			}

   449

		}

   450

		printf("\n");

   451

	}

   452

}

   453

#endif

   454

   455

const AirportFTAClass *GetAirport(const byte airport_type)

   456

{

   457

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

   458

	// needs constant change if more airports are added

   459

	switch (airport_type) {

   460

		default:               NOT_REACHED();

   461

		case AT_SMALL:         return CountryAirport;

   462

		case AT_LARGE:         return CityAirport;

   463

		case AT_METROPOLITAN:  return MetropolitanAirport;

   464

		case AT_HELIPORT:      return Heliport;

   465

		case AT_OILRIG:        return Oilrig;

   466

		case AT_INTERNATIONAL: return InternationalAirport;

   467

		case AT_COMMUTER:      return CommuterAirport;

   468

		case AT_HELIDEPOT:     return HeliDepot;

   469

		case AT_INTERCON:      return IntercontinentalAirport;

   470

		case AT_HELISTATION:   return HeliStation;

   471

	}

   472

}

   473

   474

const AirportMovingData *GetAirportMovingData(byte airport_type, byte position)

   475

{

   476

	assert(airport_type < lengthof(_airport_moving_datas));

   477

	assert(position < GetAirport(airport_type)->nofelements);

   478

	return &_airport_moving_datas[airport_type][position];

   479

}

   480

   481

uint32 GetValidAirports(void)

   482

{

   483

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

   484

   485

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

   486

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

   487

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

   488

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

   489

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

   490

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