1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "map.h"

     4

#include "airport.h"

     5

     6

AirportFTAClass *CountryAirport;

     7

AirportFTAClass *CityAirport;

     8

AirportFTAClass *Heliport, *Oilrig;

     9

AirportFTAClass *MetropolitanAirport;

    10

AirportFTAClass *InternationalAirport;

    11

    12

static void AirportFTAClass_Constructor(AirportFTAClass *Airport,

    13

																				const byte nofterminals, const byte nofterminalgroups,

    14

																				const byte nofhelipads,  const byte nofhelipadgroups,

    15

																				const byte entry_point,  const byte acc_planes,

    16

																				const AirportFTAbuildup *FA,

    18

static void AirportFTAClass_Destructor(AirportFTAClass *Airport);

    19

    20

static uint16 AirportGetNofElements(const AirportFTAbuildup *FA);

    21

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

    22

static byte AirportTestFTA(const AirportFTAClass *Airport);

    23

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

    24

static byte AirportBlockToString(uint32 block);*/

    25

    26

void InitializeAirports()

    27

{

    28

	// country airport

    29

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

    31

    32

	// city airport

    33

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

    35

    36

	// metropolitan airport

    37

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

    39

    40

	// international airport

    41

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

    43

    44

	// heliport, oilrig

    45

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

    47

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

    48

}

    49

    50

void UnInitializeAirports()

    51

{

    52

	AirportFTAClass_Destructor(CountryAirport);

    53

	AirportFTAClass_Destructor(CityAirport);

    54

	AirportFTAClass_Destructor(Heliport);

    55

	AirportFTAClass_Destructor(MetropolitanAirport);

    56

	AirportFTAClass_Destructor(InternationalAirport);

    57

}

    58

    59

static void AirportFTAClass_Constructor(AirportFTAClass *Airport,

    60

																				const byte nofterminals, const byte nofterminalgroups,

    61

																				const byte nofhelipads, const byte nofhelipadgroups,

    62

																				const byte entry_point, const byte acc_planes,

    63

																				const AirportFTAbuildup *FA,

    65

{

    66

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

    67

	// same goes for helipads

    68

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

    69

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

    70

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

    71

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

    72

	// will get the less # of terminals

    73

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

    74

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

    75

    76

	assert(nofterminals <= MAX_TERMINALS);

    77

	assert(nofhelipads <= MAX_HELIPADS);

    78

	assert(nofterminalgroups <= nofterminals);

    79

	assert(nofhelipadgroups <= nofhelipads);

    80

    81

	Airport->nofelements = AirportGetNofElements(FA);

    82

	// check

    83

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

    84

	assert(entry_point < Airport->nofelements);

    85

    86

	Airport->nofterminals = nofterminals;

    87

	Airport->nofterminalgroups = nofterminalgroups;

    88

	Airport->nofhelipads = nofhelipads;

    89

	Airport->nofhelipadgroups = nofhelipadgroups;

    90

	Airport->acc_planes = acc_planes;

    91

	Airport->entry_point = entry_point;

    94

    95

    96

	// build the state machine

    97

	AirportBuildAutomata(Airport, FA);

    98

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

    99

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

   100

   101

   102

	{

   103

		byte _retval = AirportTestFTA(Airport);

   104

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

   105

		assert(_retval == MAX_ELEMENTS);

   106

	}

   107

	// print out full information

   108

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

   109

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

   110

	//AirportPrintOut(Airport, false);

   111

}

   112

   113

static void AirportFTAClass_Destructor(AirportFTAClass *Airport)

   114

{

   115

	int i;

   116

	AirportFTA *current, *next;

   117

   118

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

   119

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

   120

		while (current != NULL) {

   121

			next = current->next_in_chain;

   122

			free(current);

   123

			current = next;

   124

		};

   125

	}

   126

	free(Airport->layout);

   127

	free(Airport);

   128

}

   129

   130

static uint16 AirportGetNofElements(const AirportFTAbuildup *FA)

   131

{

   132

	int i;

   133

	uint16 nofelements = 0;

   134

	int temp = FA[0].position;

   135

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

   136

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

   137

			nofelements++;

   138

			temp = FA[i].position;

   139

		}

   140

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

   141

	}

   142

	return nofelements;

   143

}

   144

   145

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

   146

{

   147

	AirportFTA *FAutomata;

   148

	AirportFTA *current;

   149

	uint16 internalcounter, i;

   150

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

   151

	Airport->layout = FAutomata;

   152

	internalcounter = 0;

   153

   154

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

   155

		current = &Airport->layout[i];

   156

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

   157

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

   158

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

   159

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

   160

   161

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

   162

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

   163

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

   164

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

   165

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

   166

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

   167

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

   168

			// create link

   169

			current->next_in_chain = newNode;

   170

			current = current->next_in_chain;

   171

			internalcounter++;

   172

		} // while

   173

		current->next_in_chain = NULL;

   174

		internalcounter++;

   175

	}

   176

}

   177

   178

static byte AirportTestFTA(const AirportFTAClass *Airport)

   179

{

   180

	byte position, i, next_element;

   181

	AirportFTA *temp;

   182

	next_element = 0;

   183

   184

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

   185

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

   186

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

   187

		temp = &Airport->layout[i];

   188

   189

		do {

   190

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

   191

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

   192

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

   193

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

   194

			temp = temp->next_in_chain;

   195

		} while (temp != NULL);

   196

		next_element++;

   197

	}

   198

	return MAX_ELEMENTS;

   199

}

   200

   201

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

   202

	"TO_ALL",

   203

	"HANGAR",

   204

	"TERM1",

   205

	"TERM2",

   206

	"TERM3",

   207

	"TERM4",

   208

	"TERM5",

   209

	"TERM6",

   210

	"HELIPAD1",

   211

	"HELIPAD2",

   212

	"TAKEOFF",

   213

	"STARTTAKEOFF",

   214

	"ENDTAKEOFF",

   215

	"HELITAKEOFF",

   216

	"FLYING",

   217

	"LANDING",

   218

	"ENDLANDING",

   219

	"HELILANDING",

   220

	"HELIENDLANDING",

   221

	"DUMMY"	// extra heading for 255

   222

};

   223

   224

/*

   225

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

   226

{

   227

	AirportFTA *temp;

   228

	uint16 i;

   229

	byte heading;

   230

   231

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

   232

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

   233

		temp = &Airport->layout[i];

   234

		if (full_report) {

   235

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

   236

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

   237

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

   238

		}

   239

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

   240

		while (temp->next_in_chain != NULL) {

   241

			temp = temp->next_in_chain;

   242

			if (full_report) {

   243

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

   244

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

   245

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

   246

			}

   247

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

   248

		}

   249

		printf("\n");

   250

	}

   251

}

   252

   253

   254

static byte AirportBlockToString(uint32 block)

   255

{

   256

	byte i = 0;

   257

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

   258

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

   259

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

   260

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

   261

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

   262

	return i;

   263

}*/

   264

   265

const AirportFTAClass* GetAirport(const byte airport_type)

   266

{

   267

	AirportFTAClass *Airport = NULL;

   268

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

   269

	// needs constant change if more airports are added

   270

	switch (airport_type) {

   271

		case AT_SMALL: Airport = CountryAirport; break;

   272

		case AT_LARGE: Airport = CityAirport; break;

   273

		case AT_METROPOLITAN: Airport = MetropolitanAirport; break;

   274

		case AT_HELIPORT: Airport = Heliport; break;

   275

		case AT_OILRIG: Airport = Oilrig; break;

   276

		case AT_INTERNATIONAL: Airport = InternationalAirport; break;

   277

		default:

   278

			#ifdef DEBUG__

   279

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

   280

			#endif

   281

			assert(airport_type <= AT_INTERNATIONAL);

   282

	}

   283

	return Airport;

   284

}