1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "debug.h"

     4

#include "map.h"

     5

#include "airport.h"

     8

     9

AirportFTAClass *CountryAirport;

    10

AirportFTAClass *CityAirport;

    11

AirportFTAClass *Heliport, *Oilrig;

    12

AirportFTAClass *MetropolitanAirport;

    13

AirportFTAClass *InternationalAirport;

    14

    15

static void AirportFTAClass_Constructor(AirportFTAClass *Airport,

    16

																				const byte *terminals, const byte *helipads,

    17

																				const byte entry_point,  const byte acc_planes,

    18

																				const AirportFTAbuildup *FA,

    19

																				const TileIndexDiffC *depots, const byte nof_depots);

    20

static void AirportFTAClass_Destructor(AirportFTAClass *Airport);

    21

    22

static uint16 AirportGetNofElements(const AirportFTAbuildup *FA);

    23

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

    24

static byte AirportTestFTA(const AirportFTAClass *Airport);

    25

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

    26

static byte AirportBlockToString(uint32 block);*/

    27

    28

void InitializeAirports(void)

    29

{

    30

	// country airport

    31

	CountryAirport = malloc(sizeof(AirportFTAClass));

    32

    33

	AirportFTAClass_Constructor(

    34

		CountryAirport,

    35

		_airport_terminal_country,

    36

		NULL,

    37

		16,

    38

		ALL,

    39

		_airport_fta_country,

    40

		_airport_depots_country,

    41

		lengthof(_airport_depots_country)

    42

	);

    43

    44

	// city airport

    45

	CityAirport = malloc(sizeof(AirportFTAClass));

    46

    47

	AirportFTAClass_Constructor(

    48

		CityAirport,

    49

		_airport_terminal_city,

    50

		NULL,

    51

		19,

    52

		ALL,

    53

		_airport_fta_city,

    54

		_airport_depots_city,

    55

		lengthof(_airport_depots_city)

    56

	);

    57

    58

	// metropolitan airport

    59

	MetropolitanAirport = malloc(sizeof(AirportFTAClass));

    60

    61

	AirportFTAClass_Constructor(

    62

		MetropolitanAirport,

    63

		_airport_terminal_metropolitan,

    64

		NULL,

    65

		20,

    66

		ALL,

    67

		_airport_fta_metropolitan,

    68

		_airport_depots_metropolitan,

    69

		lengthof(_airport_depots_metropolitan)

    70

	);

    71

    72

	// international airport

    73

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

    74

    75

	AirportFTAClass_Constructor(

    76

		InternationalAirport,

    77

		_airport_terminal_international,

    78

		_airport_helipad_international,

    79

		37,

    80

		ALL,

    81

		_airport_fta_international,

    82

		_airport_depots_international,

    83

		lengthof(_airport_depots_international)

    84

	);

    85

    86

	// heliport, oilrig

    87

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

    88

    89

	AirportFTAClass_Constructor(

    90

		Heliport,

    91

		NULL,

    92

		_airport_helipad_heliport_oilrig,

    93

		7,

    94

		HELICOPTERS_ONLY,

    95

		_airport_fta_heliport_oilrig,

    96

		NULL,

    97

		0

    98

	);

    99

   100

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

   101

}

   102

   103

void UnInitializeAirports(void)

   104

{

   105

	AirportFTAClass_Destructor(CountryAirport);

   106

	AirportFTAClass_Destructor(CityAirport);

   107

	AirportFTAClass_Destructor(Heliport);

   108

	AirportFTAClass_Destructor(MetropolitanAirport);

   109

	AirportFTAClass_Destructor(InternationalAirport);

   110

}

   111

   112

static void AirportFTAClass_Constructor(AirportFTAClass *Airport,

   113

																				const byte *terminals, const byte *helipads,

   114

																				const byte entry_point, const byte acc_planes,

   115

																				const AirportFTAbuildup *FA,

   116

																				const TileIndexDiffC *depots, const byte nof_depots)

   117

{

   118

	byte nofterminals, nofhelipads;

   119

	byte nofterminalgroups = 0;

   120

	byte nofhelipadgroups = 0;

   121

	const byte * curr;

   122

	int i;

   123

	nofterminals = nofhelipads = 0;

   124

   125

	//now we read the number of terminals we have

   126

	if (terminals != NULL) {

   127

		i = terminals[0];

   128

		nofterminalgroups = i;

   129

		curr = terminals;

   130

		while (i-- > 0) {

   131

			curr++;

   132

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

   133

			nofterminals += *curr;

   134

		}

   135

   136

	}

   137

	Airport->terminals = terminals;

   138

   139

	//read helipads

   140

	if (helipads != NULL) {

   141

		i = helipads[0];

   142

		nofhelipadgroups = i;

   143

		curr = helipads;

   144

		while (i-- > 0) {

   145

			curr++;

   146

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

   147

			nofhelipads += *curr;

   148

		}

   149

   150

	}

   151

	Airport->helipads = helipads;

   152

   153

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

   154

	// same goes for helipads

   155

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

   156

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

   157

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

   158

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

   159

	// will get the less # of terminals

   160

   161

	assert(nofterminals <= MAX_TERMINALS);

   162

	assert(nofhelipads <= MAX_HELIPADS);

   163

   164

	Airport->nofelements = AirportGetNofElements(FA);

   165

	// check

   166

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

   167

	assert(entry_point < Airport->nofelements);

   168

   169

	Airport->acc_planes = acc_planes;

   170

	Airport->entry_point = entry_point;

   171

	Airport->airport_depots = depots;

   172

	Airport->nof_depots = nof_depots;

   173

   174

   175

	// build the state machine

   176

	AirportBuildAutomata(Airport, FA);

   177

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

   178

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

   179

   180

   181

	{

   182

		byte _retval = AirportTestFTA(Airport);

   183

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

   184

		assert(_retval == MAX_ELEMENTS);

   185

	}

   186

	// print out full information

   187

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

   188

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

   189

	//AirportPrintOut(Airport, false);

   190

}

   191

   192

static void AirportFTAClass_Destructor(AirportFTAClass *Airport)

   193

{

   194

	int i;

   195

	AirportFTA *current, *next;

   196

   197

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

   198

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

   199

		while (current != NULL) {

   200

			next = current->next_in_chain;

   201

			free(current);

   202

			current = next;

   203

		};

   204

	}

   205

	free(Airport->layout);

   206

	free(Airport);

   207

}

   208

   209

static uint16 AirportGetNofElements(const AirportFTAbuildup *FA)

   210

{

   211

	int i;

   212

	uint16 nofelements = 0;

   213

	int temp = FA[0].position;

   214

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

   215

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

   216

			nofelements++;

   217

			temp = FA[i].position;

   218

		}

   219

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

   220

	}

   221

	return nofelements;

   222

}

   223

   224

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

   225

{

   226

	AirportFTA *FAutomata;

   227

	AirportFTA *current;

   228

	uint16 internalcounter, i;

   229

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

   230

	Airport->layout = FAutomata;

   231

	internalcounter = 0;

   232

   233

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

   234

		current = &Airport->layout[i];

   235

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

   236

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

   237

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

   238

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

   239

   240

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

   241

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

   242

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

   243

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

   244

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

   245

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

   246

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

   247

			// create link

   248

			current->next_in_chain = newNode;

   249

			current = current->next_in_chain;

   250

			internalcounter++;

   251

		} // while

   252

		current->next_in_chain = NULL;

   253

		internalcounter++;

   254

	}

   255

}

   256

   257

static byte AirportTestFTA(const AirportFTAClass *Airport)

   258

{

   259

	byte position, i, next_element;

   260

	AirportFTA *temp;

   261

	next_element = 0;

   262

   263

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

   264

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

   265

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

   266

		temp = &Airport->layout[i];

   267

   268

		do {

   269

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

   270

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

   271

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

   272

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

   273

			temp = temp->next_in_chain;

   274

		} while (temp != NULL);

   275

		next_element++;

   276

	}

   277

	return MAX_ELEMENTS;

   278

}

   279

   280

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

   281

	"TO_ALL",

   282

	"HANGAR",

   283

	"TERM1",

   284

	"TERM2",

   285

	"TERM3",

   286

	"TERM4",

   287

	"TERM5",

   288

	"TERM6",

   289

	"HELIPAD1",

   290

	"HELIPAD2",

   291

	"TAKEOFF",

   292

	"STARTTAKEOFF",

   293

	"ENDTAKEOFF",

   294

	"HELITAKEOFF",

   295

	"FLYING",

   296

	"LANDING",

   297

	"ENDLANDING",

   298

	"HELILANDING",

   299

	"HELIENDLANDING",

   300

	"DUMMY"	// extra heading for 255

   301

};

   302

   303

/*

   304

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

   305

{

   306

	AirportFTA *temp;

   307

	uint16 i;

   308

	byte heading;

   309

   310

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

   311

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

   312

		temp = &Airport->layout[i];

   313

		if (full_report) {

   314

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

   315

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

   316

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

   317

		}

   318

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

   319

		while (temp->next_in_chain != NULL) {

   320

			temp = temp->next_in_chain;

   321

			if (full_report) {

   322

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

   323

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

   324

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

   325

			}

   326

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

   327

		}

   328

		printf("\n");

   329

	}

   330

}

   331

   332

   333

static byte AirportBlockToString(uint32 block)

   334

{

   335

	byte i = 0;

   336

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

   337

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

   338

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

   339

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

   340

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

   341

	return i;

   342

}*/

   343

   344

const AirportFTAClass* GetAirport(const byte airport_type)

   345

{

   346

	AirportFTAClass *Airport = NULL;

   347

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

   348

	// needs constant change if more airports are added

   349

	switch (airport_type) {

   350

		case AT_SMALL: Airport = CountryAirport; break;

   351

		case AT_LARGE: Airport = CityAirport; break;

   352

		case AT_METROPOLITAN: Airport = MetropolitanAirport; break;

   353

		case AT_HELIPORT: Airport = Heliport; break;

   354

		case AT_OILRIG: Airport = Oilrig; break;

   355

		case AT_INTERNATIONAL: Airport = InternationalAirport; break;

   356

		default:

   357

			#ifdef DEBUG__

   358

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

   359

			#endif

   360

			assert(airport_type <= AT_INTERNATIONAL);

   361

	}

   362

	return Airport;

   363

}