1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "airport.h"

     4

     5

AirportFTAClass *CountryAirport;

     6

AirportFTAClass *CityAirport;

     7

AirportFTAClass *Heliport, *Oilrig;

     8

AirportFTAClass *MetropolitanAirport;

     9

AirportFTAClass *InternationalAirport;

    10

    11

static void AirportFTAClass_Constructor(AirportFTAClass *Airport,

    12

																				const byte nofterminals, const byte nofterminalgroups,

    13

																				const byte nofhelipads,  const byte nofhelipadgroups,

    14

																				const byte entry_point,  const byte acc_planes,

    15

																				const AirportFTAbuildup *FA,

    16

																				const TileIndex *depots);

    17

static void AirportFTAClass_Destructor(AirportFTAClass *Airport);

    18

    19

static uint16 AirportGetNofElements(const AirportFTAbuildup *FA);

    20

static void AirportBuildAutomata(AirportFTAClass *Airport, const AirportFTAbuildup *FA);

    21

static byte AirportTestFTA(const AirportFTAClass *Airport);

    22

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

    23

static byte AirportBlockToString(uint32 block);*/

    24

    25

void InitializeAirports()

    26

{

    27

	// country airport

    28

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

    29

	AirportFTAClass_Constructor(CountryAirport, 2, 1, 0, 0, 16, ALL, _airport_fta_country, _airport_depots_country);

    30

    31

	// city airport

    32

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

    33

	AirportFTAClass_Constructor(CityAirport, 3, 1, 0, 0, 19, ALL, _airport_fta_city, _airport_depots_city);

    34

    35

	// metropolitan airport

    36

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

    37

	AirportFTAClass_Constructor(MetropolitanAirport, 3, 1, 0, 0, 20, ALL, _airport_fta_metropolitan, _airport_depots_metropolitan);

    38

    39

	// international airport

    40

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

    41

	AirportFTAClass_Constructor(InternationalAirport, 6, 2, 2, 1, 37, ALL, _airport_fta_international, _airport_depots_international);

    42

    43

	// heliport, oilrig

    44

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

    45

	AirportFTAClass_Constructor(Heliport, 0, 0, 1, 1, 7, HELICOPTERS_ONLY, _airport_fta_heliport_oilrig, _airport_depots_heliport_oilrig);

    46

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

    47

}

    48

    49

void UnInitializeAirports()

    50

{

    51

	AirportFTAClass_Destructor(CountryAirport);

    52

	AirportFTAClass_Destructor(CityAirport);

    53

	AirportFTAClass_Destructor(Heliport);

    54

	AirportFTAClass_Destructor(MetropolitanAirport);

    55

	AirportFTAClass_Destructor(InternationalAirport);

    56

}

    57

    58

static void AirportFTAClass_Constructor(AirportFTAClass *Airport,

    59

																				const byte nofterminals, const byte nofterminalgroups,

    60

																				const byte nofhelipads, const byte nofhelipadgroups,

    61

																				const byte entry_point, const byte acc_planes,

    62

																				const AirportFTAbuildup *FA,

    63

																				const TileIndex *depots)

    64

{

    65

	// if there are more terminals than 6, internal variables have to be changed, so don't allow that

    66

	// same goes for helipads

    67

	if (nofterminals > MAX_TERMINALS) { printf("Currently only maximum of %2d terminals are supported (you wanted %2d)\n", MAX_TERMINALS, nofterminals);}

    68

	if (nofhelipads > MAX_HELIPADS) { printf("Currently only maximum of %2d helipads are supported (you wanted %2d)\n", MAX_HELIPADS, nofhelipads);}

    69

	// terminals/helipads are divided into groups. Groups are computed by dividing the number

    70

	// of terminals by the number of groups. Half in half. If #terminals is uneven, first group

    71

	// will get the less # of terminals

    72

	if (nofterminalgroups > nofterminals) { printf("# of terminalgroups (%2d) must be less or equal to terminals (%2d)", nofterminals, nofterminalgroups);}

    73

	if (nofhelipadgroups > nofhelipads) { printf("# of helipadgroups (%2d) must be less or equal to helipads (%2d)", nofhelipads, nofhelipadgroups);}

    74

    75

	assert(nofterminals <= MAX_TERMINALS);

    76

	assert(nofhelipads <= MAX_HELIPADS);

    77

	assert(nofterminalgroups <= nofterminals);

    78

	assert(nofhelipadgroups <= nofhelipads);

    79

    80

	Airport->nofelements = AirportGetNofElements(FA);

    81

	// check

    82

	if (entry_point >= Airport->nofelements) {printf("Entry point (%2d) must be within the airport positions (which is max %2d)\n", entry_point, Airport->nofelements);}

    83

	assert(entry_point < Airport->nofelements);

    84

    85

	Airport->nofterminals = nofterminals;

    86

	Airport->nofterminalgroups = nofterminalgroups;

    87

	Airport->nofhelipads = nofhelipads;

    88

	Airport->nofhelipadgroups = nofhelipadgroups;

    89

	Airport->acc_planes = acc_planes;

    90

	Airport->entry_point = entry_point;

    92

    93

    94

	// build the state machine

    95

	AirportBuildAutomata(Airport, FA);

    96

		DEBUG(misc, 1) ("#Elements %2d; #Terminals %2d in %d group(s); #Helipads %2d in %d group(s)", Airport->nofelements,

    97

				  Airport->nofterminals, Airport->nofterminalgroups, Airport->nofhelipads, Airport->nofhelipadgroups);

    98

    99

   100

	{

   101

		byte _retval = AirportTestFTA(Airport);

   102

		if (_retval != MAX_ELEMENTS) {printf("ERROR with element: %d\n", _retval-1);}

   103

		assert(_retval == MAX_ELEMENTS);

   104

	}

   105

	// print out full information

   106

	// true  -- full info including heading, block, etc

   107

	// false -- short info, only position and next position

   108

	//AirportPrintOut(Airport, false);

   109

}

   110

   111

static void AirportFTAClass_Destructor(AirportFTAClass *Airport)

   112

{

   113

	int i;

   114

	AirportFTA *current, *next;

   115

   116

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

   117

		current = Airport->layout[i].next_in_chain;

   118

		while (current != NULL) {

   119

			next = current->next_in_chain;

   120

			free(current);

   121

			current = next;

   122

		};

   123

	}

   124

	free(Airport->layout);

   125

	free(Airport);

   126

}

   127

   128

static uint16 AirportGetNofElements(const AirportFTAbuildup *FA)

   129

{

   130

	int i;

   131

	uint16 nofelements = 0;

   132

	int temp = FA[0].position;

   133

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

   134

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

   135

			nofelements++;

   136

			temp = FA[i].position;

   137

		}

   138

		if (FA[i].position == MAX_ELEMENTS) {break;}

   139

	}

   140

	return nofelements;

   141

}

   142

   143

static void AirportBuildAutomata(AirportFTAClass *Airport, const AirportFTAbuildup *FA)

   144

{

   145

	AirportFTA *FAutomata;

   146

	AirportFTA *current;

   147

	uint16 internalcounter, i;

   148

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

   149

	Airport->layout = FAutomata;

   150

	internalcounter = 0;

   151

   152

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

   153

		current = &Airport->layout[i];

   154

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

   155

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

   156

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

   157

		current->next_position = FA[internalcounter].next_in_chain;

   158

   159

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

   160

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

   161

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

   162

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

   163

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

   164

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

   165

			newNode->next_position = FA[internalcounter+1].next_in_chain;

   166

			// create link

   167

			current->next_in_chain = newNode;

   168

			current = current->next_in_chain;

   169

			internalcounter++;

   170

		} // while

   171

		current->next_in_chain = NULL;

   172

		internalcounter++;

   173

	}

   174

}

   175

   176

static byte AirportTestFTA(const AirportFTAClass *Airport)

   177

{

   178

	byte position, i, next_element;

   179

	AirportFTA *temp;

   180

	next_element = 0;

   181

   182

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

   183

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

   184

		if (position != next_element) {return i;}

   185

		temp = &Airport->layout[i];

   186

   187

		do {

   188

			if (temp->heading > MAX_HEADINGS && temp->heading != 255) {return i;}

   189

			if (temp->heading == 0 && temp->next_in_chain != 0) {return i;}

   190

			if (position != temp->position) {return i;}

   191

			if (temp->next_position >= Airport->nofelements) {return i;}

   192

			temp = temp->next_in_chain;

   193

		} while (temp != NULL);

   194

		next_element++;

   195

	}

   196

	return MAX_ELEMENTS;

   197

}

   198

   199

static const char* const _airport_heading_strings[MAX_HEADINGS+2] = {

   200

	"TO_ALL",

   201

	"HANGAR",

   202

	"TERM1",

   203

	"TERM2",

   204

	"TERM3",

   205

	"TERM4",

   206

	"TERM5",

   207

	"TERM6",

   208

	"HELIPAD1",

   209

	"HELIPAD2",

   210

	"TAKEOFF",

   211

	"STARTTAKEOFF",

   212

	"ENDTAKEOFF",

   213

	"HELITAKEOFF",

   214

	"FLYING",

   215

	"LANDING",

   216

	"ENDLANDING",

   217

	"HELILANDING",

   218

	"HELIENDLANDING",

   219

	"DUMMY"	// extra heading for 255

   220

};

   221

   222

/*

   223

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

   224

{

   225

	AirportFTA *temp;

   226

	uint16 i;

   227

	byte heading;

   228

   229

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

   230

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

   231

		temp = &Airport->layout[i];

   232

		if (full_report) {

   233

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

   234

			printf("Pos:%2d NPos:%2d Heading:%15s Block:%2d\n", temp->position, temp->next_position,

   235

						 _airport_heading_strings[heading], AirportBlockToString(temp->block));

   236

		}

   237

		else { printf("P:%2d NP:%2d", temp->position, temp->next_position);}

   238

		while (temp->next_in_chain != NULL) {

   239

			temp = temp->next_in_chain;

   240

			if (full_report) {

   241

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

   242

				printf("Pos:%2d NPos:%2d Heading:%15s Block:%2d\n", temp->position, temp->next_position,

   243

							_airport_heading_strings[heading], AirportBlockToString(temp->block));

   244

			}

   245

			else { printf("P:%2d NP:%2d", temp->position, temp->next_position);}

   246

		}

   247

		printf("\n");

   248

	}

   249

}

   250

   251

   252

static byte AirportBlockToString(uint32 block)

   253

{

   254

	byte i = 0;

   255

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

   256

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

   257

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

   258

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

   259

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

   260

	return i;

   261

}*/

   262

   263

const AirportFTAClass* GetAirport(const byte airport_type)

   264

{

   265

	AirportFTAClass *Airport = NULL;

   266

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

   267

	// needs constant change if more airports are added

   268

	switch (airport_type) {

   269

		case AT_SMALL: Airport = CountryAirport; break;

   270

		case AT_LARGE: Airport = CityAirport; break;

   271

		case AT_METROPOLITAN: Airport = MetropolitanAirport; break;

   272

		case AT_HELIPORT: Airport = Heliport; break;

   273

		case AT_OILRIG: Airport = Oilrig; break;

   274

		case AT_INTERNATIONAL: Airport = InternationalAirport; break;

   275

		default:

   276

			#ifdef DEBUG__

   277

				printf("Airport AircraftNextAirportPos_and_Order not yet implemented\n");

   278

			#endif

   279

			assert(airport_type <= AT_INTERNATIONAL);

   280

	}

   281

	return Airport;

   282

}