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

    13

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

    14

 * You should either use

    15

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

    16

 * OR

    17

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

    18

//#define DEBUG_AIRPORT false

    19

    20

static AirportFTAClass *CountryAirport;

    21

static AirportFTAClass *CityAirport;

    22

static AirportFTAClass *Oilrig;

    23

static AirportFTAClass *Heliport;

    24

static AirportFTAClass *MetropolitanAirport;

    25

static AirportFTAClass *InternationalAirport;

    26

static AirportFTAClass *CommuterAirport;

    27

static AirportFTAClass *HeliDepot;

    28

static AirportFTAClass *IntercontinentalAirport;

    29

static AirportFTAClass *HeliStation;

    30

    31

static void AirportFTAClass_Constructor(AirportFTAClass *apc,

    32

	const byte *terminals, const byte *helipads,

    33

	const byte entry_point,  const byte acc_planes,

    34

	const AirportFTAbuildup *apFA,

    35

	const TileIndexDiffC *depots, const byte nof_depots,

    36

	uint size_x, uint size_y

    37

);

    38

static void AirportFTAClass_Destructor(AirportFTAClass *apc);

    39

    40

static uint16 AirportGetNofElements(const AirportFTAbuildup *apFA);

    41

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

    42

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

    43

static byte AirportTestFTA(const AirportFTAClass *apc);

    44

    45

#ifdef DEBUG_AIRPORT

    46

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

    47

#endif /* DEBUG_AIRPORT */

    48

    49

void InitializeAirports(void)

    50

{

    51

	// country airport

    52

	CountryAirport = malloc(sizeof(AirportFTAClass));

    53

    54

	AirportFTAClass_Constructor(

    55

		CountryAirport,

    56

		_airport_terminal_country,

    57

		NULL,

    58

		16,

    59

		ALL,

    60

		_airport_fta_country,

    61

		_airport_depots_country,

    62

		lengthof(_airport_depots_country),

    63

		4, 3

    64

	);

    65

    66

	// city airport

    67

	CityAirport = malloc(sizeof(AirportFTAClass));

    68

    69

	AirportFTAClass_Constructor(

    70

		CityAirport,

    71

		_airport_terminal_city,

    72

		NULL,

    73

		19,

    74

		ALL,

    75

		_airport_fta_city,

    76

		_airport_depots_city,

    77

		lengthof(_airport_depots_city),

    78

		6, 6

    79

	);

    80

    81

	// metropolitan airport

    82

	MetropolitanAirport = malloc(sizeof(AirportFTAClass));

    83

    84

	AirportFTAClass_Constructor(

    85

		MetropolitanAirport,

    86

		_airport_terminal_metropolitan,

    87

		NULL,

    88

		20,

    89

		ALL,

    90

		_airport_fta_metropolitan,

    91

		_airport_depots_metropolitan,

    92

		lengthof(_airport_depots_metropolitan),

    93

		6, 6

    94

	);

    95

    96

	// international airport

    97

	InternationalAirport = (AirportFTAClass *)malloc(sizeof(AirportFTAClass));

    98

    99

	AirportFTAClass_Constructor(

   100

		InternationalAirport,

   101

		_airport_terminal_international,

   102

		_airport_helipad_international,

   103

		37,

   104

		ALL,

   105

		_airport_fta_international,

   106

		_airport_depots_international,

   107

		lengthof(_airport_depots_international),

   108

		7, 7

   109

	);

   110

   111

	// intercontintental airport

   112

	IntercontinentalAirport = (AirportFTAClass *)malloc(sizeof(AirportFTAClass));

   113

   114

	AirportFTAClass_Constructor(

   115

		IntercontinentalAirport,

   116

		_airport_terminal_intercontinental,

   117

		_airport_helipad_intercontinental,

   118

		43,

   119

		ALL,

   120

		_airport_fta_intercontinental,

   121

		_airport_depots_intercontinental,

   122

		lengthof(_airport_depots_intercontinental),

   123

		9,11

   124

	);

   125

   126

	// heliport, oilrig

   127

	Heliport = (AirportFTAClass *)malloc(sizeof(AirportFTAClass));

   128

   129

	AirportFTAClass_Constructor(

   130

		Heliport,

   131

		NULL,

   132

		_airport_helipad_heliport_oilrig,

   133

		7,

   134

		HELICOPTERS_ONLY,

   135

		_airport_fta_heliport_oilrig,

   136

		NULL,

   137

		0,

   138

		1, 1

   139

	);

   140

   141

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

   142

   143

	// commuter airport

   144

	CommuterAirport = malloc(sizeof(AirportFTAClass));

   145

   146

	AirportFTAClass_Constructor(

   147

		CommuterAirport,

   148

		_airport_terminal_commuter,

   149

		_airport_helipad_commuter,

   150

		22,

   151

		ALL,

   152

		_airport_fta_commuter,

   153

		_airport_depots_commuter,

   154

		lengthof(_airport_depots_commuter),

   155

		5,4

   156

	);

   157

   158

	// helidepot airport

   159

	HeliDepot = malloc(sizeof(AirportFTAClass));

   160

   161

	AirportFTAClass_Constructor(

   162

		HeliDepot,

   163

		NULL,

   164

		_airport_helipad_helidepot,

   165

		4,

   166

		HELICOPTERS_ONLY,

   167

		_airport_fta_helidepot,

   168

		_airport_depots_helidepot,

   169

		lengthof(_airport_depots_helidepot),

   170

		2,2

   171

	);

   172

   173

	// helistation airport

   174

	HeliStation = malloc(sizeof(AirportFTAClass));

   175

   176

	AirportFTAClass_Constructor(

   177

		HeliStation,

   178

		NULL,

   179

		_airport_helipad_helistation,

   180

		25,

   181

		HELICOPTERS_ONLY,

   182

		_airport_fta_helistation,

   183

		_airport_depots_helistation,

   184

		lengthof(_airport_depots_helistation),

   185

		4,2

   186

	);

   187

   188

}

   189

   190

void UnInitializeAirports(void)

   191

{

   192

	AirportFTAClass_Destructor(CountryAirport);

   193

	AirportFTAClass_Destructor(CityAirport);

   194

	AirportFTAClass_Destructor(Heliport);

   195

	AirportFTAClass_Destructor(MetropolitanAirport);

   196

	AirportFTAClass_Destructor(InternationalAirport);

   197

	AirportFTAClass_Destructor(CommuterAirport);

   198

	AirportFTAClass_Destructor(HeliDepot);

   199

	AirportFTAClass_Destructor(IntercontinentalAirport);

   200

	AirportFTAClass_Destructor(HeliStation);

   201

}

   202

   203

static void AirportFTAClass_Constructor(AirportFTAClass *apc,

   204

	const byte *terminals, const byte *helipads,

   205

	const byte entry_point, const byte acc_planes,

   206

	const AirportFTAbuildup *apFA,

   207

	const TileIndexDiffC *depots, const byte nof_depots,

   208

	uint size_x, uint size_y

   209

)

   210

{

   211

	byte nofterminals, nofhelipads;

   212

	byte nofterminalgroups, nofhelipadgroups;

   213

   214

	apc->size_x = size_x;

   215

	apc->size_y = size_y;

   216

   217

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

   218

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

   219

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

   220

	nofterminals = AirportGetTerminalCount(terminals, &nofterminalgroups);

   221

	if (nofterminals > MAX_TERMINALS) {

   222

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

   223

		assert(nofterminals <= MAX_TERMINALS);

   224

	}

   225

	apc->terminals = terminals;

   226

   227

	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

	apc->helipads = helipads;

   233

   234

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

   235

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

   236

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

   237

	apc->nofelements = AirportGetNofElements(apFA);

   238

	if (entry_point >= apc->nofelements) {

   239

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

   240

		assert(entry_point < apc->nofelements);

   241

	}

   242

   243

	apc->acc_planes     = acc_planes;

   244

	apc->entry_point    = entry_point;

   245

	apc->airport_depots = depots;

   246

	apc->nof_depots     = nof_depots;

   247

   248

	/* Build the state machine itself */

   249

	AirportBuildAutomata(apc, apFA);

   250

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

   251

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

   252

   253

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

   254

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

   255

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

   256

	{ byte ret = AirportTestFTA(apc);

   257

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

   258

		assert(ret == MAX_ELEMENTS);

   259

	}

   260

   261

#ifdef DEBUG_AIRPORT

   262

	AirportPrintOut(apc, DEBUG_AIRPORT);

   263

#endif

   264

}

   265

   266

static void AirportFTAClass_Destructor(AirportFTAClass *apc)

   267

{

   268

	int i;

   269

	AirportFTA *current, *next;

   270

   271

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

   272

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

   273

		while (current != NULL) {

   274

			next = current->next;

   275

			free(current);

   276

			current = next;

   277

		};

   278

	}

   279

	free(apc->layout);

   280

	free(apc);

   281

}

   282

   283

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

   284

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

   285

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

   286

static uint16 AirportGetNofElements(const AirportFTAbuildup *apFA)

   287

{

   288

	int i;

   289

	uint16 nofelements = 0;

   290

	int temp = apFA[0].position;

   291

   292

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

   293

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

   294

			nofelements++;

   295

			temp = apFA[i].position;

   296

		}

   297

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

   298

	}

   299

	return nofelements;

   300

}

   301

   302

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

   303

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

   304

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

   305

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

   306

{

   307

	byte i;

   308

	byte nof_terminals = 0;

   309

	*groups = 0;

   310

   311

	if (terminals != NULL) {

   312

		i = terminals[0];

   313

		*groups = i;

   314

		while (i-- > 0) {

   315

			terminals++;

   316

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

   317

			nof_terminals += *terminals;

   318

		}

   319

	}

   320

	return nof_terminals;

   321

}

   322

   323

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

   324

{

   325

	AirportFTA *current;

   326

	AirportFTA *FAutomata = malloc(sizeof(AirportFTA) * apc->nofelements);

   327

	uint16 internalcounter = 0;

   328

	uint16 i;

   329

   330

	apc->layout = FAutomata;

   331

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

   332

		current = &apc->layout[i];

   333

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

   334

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

   335

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

   336

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

   337

   338

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

   339

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

   340

			AirportFTA *newNode = malloc(sizeof(AirportFTA));

   341

   342

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

   343

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

   344

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

   345

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

   346

			// create link

   347

			current->next = newNode;

   348

			current = current->next;

   349

			internalcounter++;

   350

		} // while

   351

		current->next = NULL;

   352

		internalcounter++;

   353

	}

   354

}

   355

   356

static byte AirportTestFTA(const AirportFTAClass *apc)

   357

{

   358

	byte position, i, next_position;

   359

	AirportFTA *current, *first;

   360

	next_position = 0;

   361

   362

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

   363

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

   364

		if (position != next_position) return i;

   365

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

   366

   367

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

   368

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

   369

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

   370

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

   371

			if (current->heading > MAX_HEADINGS) {

   372

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

   373

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

   374

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

   375

			}

   376

   377

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

   378

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

   379

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

   380

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

   381

			/* A next position must be within bounds */

   382

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

   383

		}

   384

		next_position++;

   385

	}

   386

	return MAX_ELEMENTS;

   387

}

   388

   389

#ifdef DEBUG_AIRPORT

   390

static const char* const _airport_heading_strings[] = {

   391

	"TO_ALL",

   392

	"HANGAR",

   393

	"TERM1",

   394

	"TERM2",

   395

	"TERM3",

   396

	"TERM4",

   397

	"TERM5",

   398

	"TERM6",

   399

	"HELIPAD1",

   400

	"HELIPAD2",

   401

	"TAKEOFF",

   402

	"STARTTAKEOFF",

   403

	"ENDTAKEOFF",

   404

	"HELITAKEOFF",

   405

	"FLYING",

   406

	"LANDING",

   407

	"ENDLANDING",

   408

	"HELILANDING",

   409

	"HELIENDLANDING",

   410

	"TERM7",

   411

	"TERM8",

   412

	"HELIPAD3",

   413

	"HELIPAD4",

   414

	"DUMMY" // extra heading for 255

   415

};

   416

   417

static uint AirportBlockToString(uint32 block)

   418

{

   419

	uint i = 0;

   420

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

   421

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

   422

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

   423

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

   424

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

   425

	return i;

   426

}

   427

   428

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

   429

{

   430

	uint16 i;

   431

   432

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

   433

   434

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

   435

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

   436

   437

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

   438

			if (full_report) {

   439

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

   440

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

   441

					    current->next_position, _airport_heading_strings[heading],

   442

							AirportBlockToString(current->block));

   443

			} else {

   444

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

   445

			}

   446

		}

   447

		printf("\n");

   448

	}

   449

}

   450

#endif

   451

   452

const AirportFTAClass *GetAirport(const byte airport_type)

   453

{

   454

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

   455

	// needs constant change if more airports are added

   456

	switch (airport_type) {

   457

		default:               NOT_REACHED();

   458

		case AT_SMALL:         return CountryAirport;

   459

		case AT_LARGE:         return CityAirport;

   460

		case AT_METROPOLITAN:  return MetropolitanAirport;

   461

		case AT_HELIPORT:      return Heliport;

   462

		case AT_OILRIG:        return Oilrig;

   463

		case AT_INTERNATIONAL: return InternationalAirport;

   464

		case AT_COMMUTER:      return CommuterAirport;

   465

		case AT_HELIDEPOT:     return HeliDepot;

   466

		case AT_INTERCON:      return IntercontinentalAirport;

   467

		case AT_HELISTATION:   return HeliStation;

   468

	}

   469

}

   470

   471

const AirportMovingData *GetAirportMovingData(byte airport_type, byte position)

   472

{

   473

	assert(airport_type < lengthof(_airport_moving_datas));

   474

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

   475

	return &_airport_moving_datas[airport_type][position];

   476

}

   477

   478

uint32 GetValidAirports(void)

   479

{

   480

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

   481

   482

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

   483

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

   484

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

   485

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

   486

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

   487

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

   488

	return bytemask;

   489

}