1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "debug.h"

     4

#include "map.h"

     5

#include "airport.h"

     6

     7

AirportFTAClass *CountryAirport;

     8

AirportFTAClass *CityAirport;

     9

AirportFTAClass *Heliport, *Oilrig;

    10

AirportFTAClass *MetropolitanAirport;

    11

AirportFTAClass *InternationalAirport;

    12

    13

static void AirportFTAClass_Constructor(AirportFTAClass *Airport,

    14

																				const byte *terminals, const byte *helipads,

    15

																				const byte entry_point,  const byte acc_planes,

    16

																				const AirportFTAbuildup *FA,

    17

																				const TileIndexDiffC *depots, const byte nof_depots);

    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(void)

    27

{

    28

	// country airport

    29

	CountryAirport = malloc(sizeof(AirportFTAClass));

    30

    31

	AirportFTAClass_Constructor(

    32

		CountryAirport,

    33

		_airport_terminal_country,

    34

		NULL,

    35

		16,

    36

		ALL,

    37

		_airport_fta_country,

    38

		_airport_depots_country,

    39

		lengthof(_airport_depots_country)

    40

	);

    41

    42

	// city airport

    43

	CityAirport = malloc(sizeof(AirportFTAClass));

    44

    45

	AirportFTAClass_Constructor(

    46

		CityAirport,

    47

		_airport_terminal_city,

    48

		NULL,

    49

		19,

    50

		ALL,

    51

		_airport_fta_city,

    52

		_airport_depots_city,

    53

		lengthof(_airport_depots_city)

    54

	);

    55

    56

	// metropolitan airport

    57

	MetropolitanAirport = malloc(sizeof(AirportFTAClass));

    58

    59

	AirportFTAClass_Constructor(

    60

		MetropolitanAirport,

    61

		_airport_terminal_metropolitan,

    62

		NULL,

    63

		20,

    64

		ALL,

    65

		_airport_fta_metropolitan,

    66

		_airport_depots_metropolitan,

    67

		lengthof(_airport_depots_metropolitan)

    68

	);

    69

    70

	// international airport

    71

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

    72

    73

	AirportFTAClass_Constructor(

    74

		InternationalAirport,

    75

		_airport_terminal_international,

    76

		_airport_helipad_international,

    77

		37,

    78

		ALL,

    79

		_airport_fta_international,

    80

		_airport_depots_international,

    81

		lengthof(_airport_depots_international)

    82

	);

    83

    84

	// heliport, oilrig

    85

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

    86

    87

	AirportFTAClass_Constructor(

    88

		Heliport,

    89

		NULL,

    90

		_airport_helipad_heliport_oilrig,

    91

		7,

    92

		HELICOPTERS_ONLY,

    93

		_airport_fta_heliport_oilrig,

    94

		NULL,

    95

		0

    96

	);

    97

    98

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

    99

}

   100

   101

void UnInitializeAirports(void)

   102

{

   103

	AirportFTAClass_Destructor(CountryAirport);

   104

	AirportFTAClass_Destructor(CityAirport);

   105

	AirportFTAClass_Destructor(Heliport);

   106

	AirportFTAClass_Destructor(MetropolitanAirport);

   107

	AirportFTAClass_Destructor(InternationalAirport);

   108

}

   109

   110

static void AirportFTAClass_Constructor(AirportFTAClass *Airport,

   111

																				const byte *terminals, const byte *helipads,

   112

																				const byte entry_point, const byte acc_planes,

   113

																				const AirportFTAbuildup *FA,

   114

																				const TileIndexDiffC *depots, const byte nof_depots)

   115

{

   116

	byte nofterminals, nofhelipads;

   117

	byte nofterminalgroups = 0;

   118

	byte nofhelipadgroups = 0;

   119

	const byte * curr;

   120

	int i;

   121

	nofterminals = nofhelipads = 0;

   122

   123

	//now we read the number of terminals we have

   124

	if (terminals != NULL) {

   125

		i = terminals[0];

   126

		nofterminalgroups = i;

   127

		curr = terminals;

   128

		while (i-- > 0) {

   129

			curr++;

   130

			assert(*curr != 0);	//we don't want to have an empty group

   131

			nofterminals += *curr;

   132

		}

   133

   134

	}

   135

	Airport->terminals = terminals;

   136

   137

	//read helipads

   138

	if (helipads != NULL) {

   139

		i = helipads[0];

   140

		nofhelipadgroups = i;

   141

		curr = helipads;

   142

		while (i-- > 0) {

   143

			curr++;

   144

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

   145

			nofhelipads += *curr;

   146

		}

   147

   148

	}

   149

	Airport->helipads = helipads;

   150

   151

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

   152

	// same goes for helipads

   153

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

   154

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

   155

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

   156

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

   157

	// will get the less # of terminals

   158

   159

	assert(nofterminals <= MAX_TERMINALS);

   160

	assert(nofhelipads <= MAX_HELIPADS);

   161

   162

	Airport->nofelements = AirportGetNofElements(FA);

   163

	// check

   164

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

   165

	assert(entry_point < Airport->nofelements);

   166

   167

	Airport->acc_planes = acc_planes;

   168

	Airport->entry_point = entry_point;

   169

	Airport->airport_depots = depots;

   170

	Airport->nof_depots = nof_depots;

   171

   172

   173

	// build the state machine

   174

	AirportBuildAutomata(Airport, FA);

   175

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

   176

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

   177

   178

   179

	{

   180

		byte _retval = AirportTestFTA(Airport);

   181

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

   182

		assert(_retval == MAX_ELEMENTS);

   183

	}

   184

	// print out full information

   185

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

   186

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

   187

	//AirportPrintOut(Airport, false);

   188

}

   189

   190

static void AirportFTAClass_Destructor(AirportFTAClass *Airport)

   191

{

   192

	int i;

   193

	AirportFTA *current, *next;

   194

   195

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

   196

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

   197

		while (current != NULL) {

   198

			next = current->next_in_chain;

   199

			free(current);

   200

			current = next;

   201

		};

   202

	}

   203

	free(Airport->layout);

   204

	free(Airport);

   205

}

   206

   207

static uint16 AirportGetNofElements(const AirportFTAbuildup *FA)

   208

{

   209

	int i;

   210

	uint16 nofelements = 0;

   211

	int temp = FA[0].position;

   212

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

   213

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

   214

			nofelements++;

   215

			temp = FA[i].position;

   216

		}

   217

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

   218

	}

   219

	return nofelements;

   220

}

   221

   222

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

   223

{

   224

	AirportFTA *FAutomata;

   225

	AirportFTA *current;

   226

	uint16 internalcounter, i;

   227

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

   228

	Airport->layout = FAutomata;

   229

	internalcounter = 0;

   230

   231

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

   232

		current = &Airport->layout[i];

   233

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

   234

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

   235

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

   236

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

   237

   238

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

   239

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

   240

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

   241

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

   242

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

   243

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

   244

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

   245

			// create link

   246

			current->next_in_chain = newNode;

   247

			current = current->next_in_chain;

   248

			internalcounter++;

   249

		} // while

   250

		current->next_in_chain = NULL;

   251

		internalcounter++;

   252

	}

   253

}

   254

   255

static byte AirportTestFTA(const AirportFTAClass *Airport)

   256

{

   257

	byte position, i, next_element;

   258

	AirportFTA *temp;

   259

	next_element = 0;

   260

   261

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

   262

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

   263

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

   264

		temp = &Airport->layout[i];

   265

   266

		do {

   267

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

   268

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

   269

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

   270

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

   271

			temp = temp->next_in_chain;

   272

		} while (temp != NULL);

   273

		next_element++;

   274

	}

   275

	return MAX_ELEMENTS;

   276

}

   277

   278

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

   279

	"TO_ALL",

   280

	"HANGAR",

   281

	"TERM1",

   282

	"TERM2",

   283

	"TERM3",

   284

	"TERM4",

   285

	"TERM5",

   286

	"TERM6",

   287

	"HELIPAD1",

   288

	"HELIPAD2",

   289

	"TAKEOFF",

   290

	"STARTTAKEOFF",

   291

	"ENDTAKEOFF",

   292

	"HELITAKEOFF",

   293

	"FLYING",

   294

	"LANDING",

   295

	"ENDLANDING",

   296

	"HELILANDING",

   297

	"HELIENDLANDING",

   298

	"DUMMY"	// extra heading for 255

   299

};

   300

   301

/*

   302

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

   303

{

   304

	AirportFTA *temp;

   305

	uint16 i;

   306

	byte heading;

   307

   308

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

   309

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

   310

		temp = &Airport->layout[i];

   311

		if (full_report) {

   312

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

   313

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

   314

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

   315

		}

   316

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

   317

		while (temp->next_in_chain != NULL) {

   318

			temp = temp->next_in_chain;

   319

			if (full_report) {

   320

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

   321

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

   322

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

   323

			}

   324

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

   325

		}

   326

		printf("\n");

   327

	}

   328

}

   329

   330

   331

static byte AirportBlockToString(uint32 block)

   332

{

   333

	byte i = 0;

   334

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

   335

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

   336

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

   337

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

   338

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

   339

	return i;

   340

}*/

   341

   342

const AirportFTAClass* GetAirport(const byte airport_type)

   343

{

   344

	AirportFTAClass *Airport = NULL;

   345

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

   346

	// needs constant change if more airports are added

   347

	switch (airport_type) {

   348

		case AT_SMALL: Airport = CountryAirport; break;

   349

		case AT_LARGE: Airport = CityAirport; break;

   350

		case AT_METROPOLITAN: Airport = MetropolitanAirport; break;

   351

		case AT_HELIPORT: Airport = Heliport; break;

   352

		case AT_OILRIG: Airport = Oilrig; break;

   353

		case AT_INTERNATIONAL: Airport = InternationalAirport; break;

   354

		default:

   355

			#ifdef DEBUG__

   356

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

   357

			#endif

   358

			assert(airport_type <= AT_INTERNATIONAL);

   359

	}

   360

	return Airport;

   361

}