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

    11

AirportFTAClass *CountryAirport;

    12

AirportFTAClass *CityAirport;

    13

AirportFTAClass *Heliport, *Oilrig;

    14

AirportFTAClass *MetropolitanAirport;

    15

AirportFTAClass *InternationalAirport;

    16

    17

static void AirportFTAClass_Constructor(AirportFTAClass *Airport,

    18

																				const byte *terminals, const byte *helipads,

    19

																				const byte entry_point,  const byte acc_planes,

    20

																				const AirportFTAbuildup *FA,

    21

																				const TileIndexDiffC *depots, const byte nof_depots);

    22

static void AirportFTAClass_Destructor(AirportFTAClass *Airport);

    23

    24

static uint16 AirportGetNofElements(const AirportFTAbuildup *FA);

    25

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

    26

static byte AirportTestFTA(const AirportFTAClass *Airport);

    27

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

    28

static byte AirportBlockToString(uint32 block);*/

    29

    30

void InitializeAirports(void)

    31

{

    32

	// country airport

    33

	CountryAirport = malloc(sizeof(AirportFTAClass));

    34

    35

	AirportFTAClass_Constructor(

    36

		CountryAirport,

    37

		_airport_terminal_country,

    38

		NULL,

    39

		16,

    40

		ALL,

    41

		_airport_fta_country,

    42

		_airport_depots_country,

    43

		lengthof(_airport_depots_country)

    44

	);

    45

    46

	// city airport

    47

	CityAirport = malloc(sizeof(AirportFTAClass));

    48

    49

	AirportFTAClass_Constructor(

    50

		CityAirport,

    51

		_airport_terminal_city,

    52

		NULL,

    53

		19,

    54

		ALL,

    55

		_airport_fta_city,

    56

		_airport_depots_city,

    57

		lengthof(_airport_depots_city)

    58

	);

    59

    60

	// metropolitan airport

    61

	MetropolitanAirport = malloc(sizeof(AirportFTAClass));

    62

    63

	AirportFTAClass_Constructor(

    64

		MetropolitanAirport,

    65

		_airport_terminal_metropolitan,

    66

		NULL,

    67

		20,

    68

		ALL,

    69

		_airport_fta_metropolitan,

    70

		_airport_depots_metropolitan,

    71

		lengthof(_airport_depots_metropolitan)

    72

	);

    73

    74

	// international airport

    75

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

    76

    77

	AirportFTAClass_Constructor(

    78

		InternationalAirport,

    79

		_airport_terminal_international,

    80

		_airport_helipad_international,

    81

		37,

    82

		ALL,

    83

		_airport_fta_international,

    84

		_airport_depots_international,

    85

		lengthof(_airport_depots_international)

    86

	);

    87

    88

	// heliport, oilrig

    89

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

    90

    91

	AirportFTAClass_Constructor(

    92

		Heliport,

    93

		NULL,

    94

		_airport_helipad_heliport_oilrig,

    95

		7,

    96

		HELICOPTERS_ONLY,

    97

		_airport_fta_heliport_oilrig,

    98

		NULL,

    99

		0

   100

	);

   101

   102

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

   103

}

   104

   105

void UnInitializeAirports(void)

   106

{

   107

	AirportFTAClass_Destructor(CountryAirport);

   108

	AirportFTAClass_Destructor(CityAirport);

   109

	AirportFTAClass_Destructor(Heliport);

   110

	AirportFTAClass_Destructor(MetropolitanAirport);

   111

	AirportFTAClass_Destructor(InternationalAirport);

   112

}

   113

   114

static void AirportFTAClass_Constructor(AirportFTAClass *Airport,

   115

																				const byte *terminals, const byte *helipads,

   116

																				const byte entry_point, const byte acc_planes,

   117

																				const AirportFTAbuildup *FA,

   118

																				const TileIndexDiffC *depots, const byte nof_depots)

   119

{

   120

	byte nofterminals, nofhelipads;

   121

	byte nofterminalgroups = 0;

   122

	byte nofhelipadgroups = 0;

   123

	const byte * curr;

   124

	int i;

   125

	nofterminals = nofhelipads = 0;

   126

   127

	//now we read the number of terminals we have

   128

	if (terminals != NULL) {

   129

		i = terminals[0];

   130

		nofterminalgroups = i;

   131

		curr = terminals;

   132

		while (i-- > 0) {

   133

			curr++;

   134

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

   135

			nofterminals += *curr;

   136

		}

   137

   138

	}

   139

	Airport->terminals = terminals;

   140

   141

	//read helipads

   142

	if (helipads != NULL) {

   143

		i = helipads[0];

   144

		nofhelipadgroups = i;

   145

		curr = helipads;

   146

		while (i-- > 0) {

   147

			curr++;

   148

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

   149

			nofhelipads += *curr;

   150

		}

   151

   152

	}

   153

	Airport->helipads = helipads;

   154

   155

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

   156

	// same goes for helipads

   157

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

   158

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

   159

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

   160

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

   161

	// will get the less # of terminals

   162

   163

	assert(nofterminals <= MAX_TERMINALS);

   164

	assert(nofhelipads <= MAX_HELIPADS);

   165

   166

	Airport->nofelements = AirportGetNofElements(FA);

   167

	// check

   168

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

   169

	assert(entry_point < Airport->nofelements);

   170

   171

	Airport->acc_planes = acc_planes;

   172

	Airport->entry_point = entry_point;

   173

	Airport->airport_depots = depots;

   174

	Airport->nof_depots = nof_depots;

   175

   176

   177

	// build the state machine

   178

	AirportBuildAutomata(Airport, FA);

   179

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

   180

		Airport->nofelements, nofterminals, nofterminalgroups, nofhelipads, nofhelipadgroups, Airport->entry_point

   181

	);

   182

   183

   184

	{

   185

		byte ret = AirportTestFTA(Airport);

   186

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

   187

		assert(ret == MAX_ELEMENTS);

   188

	}

   189

	// print out full information

   190

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

   191

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

   192

	//AirportPrintOut(Airport, false);

   193

}

   194

   195

static void AirportFTAClass_Destructor(AirportFTAClass *Airport)

   196

{

   197

	int i;

   198

	AirportFTA *current, *next;

   199

   200

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

   201

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

   202

		while (current != NULL) {

   203

			next = current->next_in_chain;

   204

			free(current);

   205

			current = next;

   206

		};

   207

	}

   208

	free(Airport->layout);

   209

	free(Airport);

   210

}

   211

   212

static uint16 AirportGetNofElements(const AirportFTAbuildup *FA)

   213

{

   214

	int i;

   215

	uint16 nofelements = 0;

   216

	int temp = FA[0].position;

   217

   218

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

   219

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

   220

			nofelements++;

   221

			temp = FA[i].position;

   222

		}

   223

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

   224

	}

   225

	return nofelements;

   226

}

   227

   228

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

   229

{

   230

	AirportFTA *FAutomata;

   231

	AirportFTA *current;

   232

	uint16 internalcounter, i;

   233

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

   234

	Airport->layout = FAutomata;

   235

	internalcounter = 0;

   236

   237

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

   238

		current = &Airport->layout[i];

   239

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

   240

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

   241

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

   242

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

   243

   244

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

   245

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

   246

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

   247

   248

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

   249

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

   250

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

   251

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

   252

			// create link

   253

			current->next_in_chain = newNode;

   254

			current = current->next_in_chain;

   255

			internalcounter++;

   256

		} // while

   257

		current->next_in_chain = NULL;

   258

		internalcounter++;

   259

	}

   260

}

   261

   262

static byte AirportTestFTA(const AirportFTAClass *Airport)

   263

{

   264

	byte position, i, next_element;

   265

	AirportFTA *temp;

   266

	next_element = 0;

   267

   268

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

   269

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

   270

		if (position != next_element) return i;

   271

		temp = &Airport->layout[i];

   272

   273

		do {

   274

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

   275

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

   276

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

   277

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

   278

			temp = temp->next_in_chain;

   279

		} while (temp != NULL);

   280

		next_element++;

   281

	}

   282

	return MAX_ELEMENTS;

   283

}

   284

   285

#if 0

   286

static const char* const _airport_heading_strings[] = {

   287

	"TO_ALL",

   288

	"HANGAR",

   289

	"TERM1",

   290

	"TERM2",

   291

	"TERM3",

   292

	"TERM4",

   293

	"TERM5",

   294

	"TERM6",

   295

	"HELIPAD1",

   296

	"HELIPAD2",

   297

	"TAKEOFF",

   298

	"STARTTAKEOFF",

   299

	"ENDTAKEOFF",

   300

	"HELITAKEOFF",

   301

	"FLYING",

   302

	"LANDING",

   303

	"ENDLANDING",

   304

	"HELILANDING",

   305

	"HELIENDLANDING",

   306

	"DUMMY"	// extra heading for 255

   307

};

   308

   309

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

   310

{

   311

	AirportFTA *temp;

   312

	uint16 i;

   313

	byte heading;

   314

   315

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

   316

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

   317

		temp = &Airport->layout[i];

   318

		if (full_report) {

   319

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

   320

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

   321

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

   322

		} else {

   323

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

   324

		}

   325

		while (temp->next_in_chain != NULL) {

   326

			temp = temp->next_in_chain;

   327

			if (full_report) {

   328

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

   329

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

   330

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

   331

			} else {

   332

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

   333

			}

   334

		}

   335

		printf("\n");

   336

	}

   337

}

   338

   339

   340

static byte AirportBlockToString(uint32 block)

   341

{

   342

	byte i = 0;

   343

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

   344

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

   345

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

   346

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

   347

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

   348

	return i;

   349

}

   350

#endif

   351

   352

const AirportFTAClass* GetAirport(const byte airport_type)

   353

{

   354

	AirportFTAClass *Airport = NULL;

   355

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

   356

	// needs constant change if more airports are added

   357

	switch (airport_type) {

   358

		case AT_SMALL: Airport = CountryAirport; break;

   359

		case AT_LARGE: Airport = CityAirport; break;

   360

		case AT_METROPOLITAN: Airport = MetropolitanAirport; break;

   361

		case AT_HELIPORT: Airport = Heliport; break;

   362

		case AT_OILRIG: Airport = Oilrig; break;

   363

		case AT_INTERNATIONAL: Airport = InternationalAirport; break;

   364

		default:

   365

			#ifdef DEBUG__

   366

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

   367

			#endif

   368

			assert(airport_type <= AT_INTERNATIONAL);

   369

	}

   370

	return Airport;

   371

}

   372

   373

uint32 GetValidAirports(void)

   374

{

   375

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

   376

   377

	// 1980-1-1 is --> 21915

   378

	// 1990-1-1 is --> 25568

   379

	if (_date >= 21915) {SETBIT(bytemask, 3);}	// metropilitan airport 1980

   380

	if (_date >= 25568) {SETBIT(bytemask, 4);}	// international airport 1990

   381

	return bytemask;

   382

}