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

static AirportFTAClass* CountryAirport;

    12

static AirportFTAClass* CityAirport;

    13

static AirportFTAClass* Oilrig;

    14

static AirportFTAClass* Heliport;

    15

static AirportFTAClass* MetropolitanAirport;

    16

static AirportFTAClass* InternationalAirport;

    17

    18

static void AirportFTAClass_Constructor(AirportFTAClass *Airport,

    19

																				const byte *terminals, const byte *helipads,

    20

																				const byte entry_point,  const byte acc_planes,

    21

																				const AirportFTAbuildup *FA,

    22

																				const TileIndexDiffC *depots, const byte nof_depots);

    23

static void AirportFTAClass_Destructor(AirportFTAClass *Airport);

    24

    25

static uint16 AirportGetNofElements(const AirportFTAbuildup *FA);

    26

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

    27

static byte AirportTestFTA(const AirportFTAClass *Airport);

    28

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

    29

static byte AirportBlockToString(uint32 block);*/

    30

    31

void InitializeAirports(void)

    32

{

    33

	// country airport

    34

	CountryAirport = malloc(sizeof(AirportFTAClass));

    35

    36

	AirportFTAClass_Constructor(

    37

		CountryAirport,

    38

		_airport_terminal_country,

    39

		NULL,

    40

		16,

    41

		ALL,

    42

		_airport_fta_country,

    43

		_airport_depots_country,

    44

		lengthof(_airport_depots_country)

    45

	);

    46

    47

	// city airport

    48

	CityAirport = malloc(sizeof(AirportFTAClass));

    49

    50

	AirportFTAClass_Constructor(

    51

		CityAirport,

    52

		_airport_terminal_city,

    53

		NULL,

    54

		19,

    55

		ALL,

    56

		_airport_fta_city,

    57

		_airport_depots_city,

    58

		lengthof(_airport_depots_city)

    59

	);

    60

    61

	// metropolitan airport

    62

	MetropolitanAirport = malloc(sizeof(AirportFTAClass));

    63

    64

	AirportFTAClass_Constructor(

    65

		MetropolitanAirport,

    66

		_airport_terminal_metropolitan,

    67

		NULL,

    68

		20,

    69

		ALL,

    70

		_airport_fta_metropolitan,

    71

		_airport_depots_metropolitan,

    72

		lengthof(_airport_depots_metropolitan)

    73

	);

    74

    75

	// international airport

    76

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

    77

    78

	AirportFTAClass_Constructor(

    79

		InternationalAirport,

    80

		_airport_terminal_international,

    81

		_airport_helipad_international,

    82

		37,

    83

		ALL,

    84

		_airport_fta_international,

    85

		_airport_depots_international,

    86

		lengthof(_airport_depots_international)

    87

	);

    88

    89

	// heliport, oilrig

    90

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

    91

    92

	AirportFTAClass_Constructor(

    93

		Heliport,

    94

		NULL,

    95

		_airport_helipad_heliport_oilrig,

    96

		7,

    97

		HELICOPTERS_ONLY,

    98

		_airport_fta_heliport_oilrig,

    99

		NULL,

   100

		0

   101

	);

   102

   103

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

   104

}

   105

   106

void UnInitializeAirports(void)

   107

{

   108

	AirportFTAClass_Destructor(CountryAirport);

   109

	AirportFTAClass_Destructor(CityAirport);

   110

	AirportFTAClass_Destructor(Heliport);

   111

	AirportFTAClass_Destructor(MetropolitanAirport);

   112

	AirportFTAClass_Destructor(InternationalAirport);

   113

}

   114

   115

static void AirportFTAClass_Constructor(AirportFTAClass *Airport,

   116

																				const byte *terminals, const byte *helipads,

   117

																				const byte entry_point, const byte acc_planes,

   118

																				const AirportFTAbuildup *FA,

   119

																				const TileIndexDiffC *depots, const byte nof_depots)

   120

{

   121

	byte nofterminals, nofhelipads;

   122

	byte nofterminalgroups = 0;

   123

	byte nofhelipadgroups = 0;

   124

	const byte * curr;

   125

	int i;

   126

	nofterminals = nofhelipads = 0;

   127

   128

	//now we read the number of terminals we have

   129

	if (terminals != NULL) {

   130

		i = terminals[0];

   131

		nofterminalgroups = i;

   132

		curr = terminals;

   133

		while (i-- > 0) {

   134

			curr++;

   135

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

   136

			nofterminals += *curr;

   137

		}

   138

   139

	}

   140

	Airport->terminals = terminals;

   141

   142

	//read helipads

   143

	if (helipads != NULL) {

   144

		i = helipads[0];

   145

		nofhelipadgroups = i;

   146

		curr = helipads;

   147

		while (i-- > 0) {

   148

			curr++;

   149

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

   150

			nofhelipads += *curr;

   151

		}

   152

   153

	}

   154

	Airport->helipads = helipads;

   155

   156

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

   157

	// same goes for helipads

   158

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

   159

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

   160

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

   161

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

   162

	// will get the less # of terminals

   163

   164

	assert(nofterminals <= MAX_TERMINALS);

   165

	assert(nofhelipads <= MAX_HELIPADS);

   166

   167

	Airport->nofelements = AirportGetNofElements(FA);

   168

	// check

   169

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

   170

	assert(entry_point < Airport->nofelements);

   171

   172

	Airport->acc_planes = acc_planes;

   173

	Airport->entry_point = entry_point;

   174

	Airport->airport_depots = depots;

   175

	Airport->nof_depots = nof_depots;

   176

   177

   178

	// build the state machine

   179

	AirportBuildAutomata(Airport, FA);

   180

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

   181

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

   182

	);

   183

   184

   185

	{

   186

		byte ret = AirportTestFTA(Airport);

   187

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

   188

		assert(ret == MAX_ELEMENTS);

   189

	}

   190

	// print out full information

   191

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

   192

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

   193

	//AirportPrintOut(Airport, false);

   194

}

   195

   196

static void AirportFTAClass_Destructor(AirportFTAClass *Airport)

   197

{

   198

	int i;

   199

	AirportFTA *current, *next;

   200

   201

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

   202

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

   203

		while (current != NULL) {

   204

			next = current->next_in_chain;

   205

			free(current);

   206

			current = next;

   207

		};

   208

	}

   209

	free(Airport->layout);

   210

	free(Airport);

   211

}

   212

   213

static uint16 AirportGetNofElements(const AirportFTAbuildup *FA)

   214

{

   215

	int i;

   216

	uint16 nofelements = 0;

   217

	int temp = FA[0].position;

   218

   219

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

   220

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

   221

			nofelements++;

   222

			temp = FA[i].position;

   223

		}

   224

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

   225

	}

   226

	return nofelements;

   227

}

   228

   229

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

   230

{

   231

	AirportFTA *FAutomata;

   232

	AirportFTA *current;

   233

	uint16 internalcounter, i;

   234

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

   235

	Airport->layout = FAutomata;

   236

	internalcounter = 0;

   237

   238

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

   239

		current = &Airport->layout[i];

   240

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

   241

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

   242

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

   243

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

   244

   245

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

   246

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

   247

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

   248

   249

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

   250

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

   251

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

   252

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

   253

			// create link

   254

			current->next_in_chain = newNode;

   255

			current = current->next_in_chain;

   256

			internalcounter++;

   257

		} // while

   258

		current->next_in_chain = NULL;

   259

		internalcounter++;

   260

	}

   261

}

   262

   263

static byte AirportTestFTA(const AirportFTAClass *Airport)

   264

{

   265

	byte position, i, next_element;

   266

	AirportFTA *temp;

   267

	next_element = 0;

   268

   269

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

   270

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

   271

		if (position != next_element) return i;

   272

		temp = &Airport->layout[i];

   273

   274

		do {

   275

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

   276

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

   277

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

   278

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

   279

			temp = temp->next_in_chain;

   280

		} while (temp != NULL);

   281

		next_element++;

   282

	}

   283

	return MAX_ELEMENTS;

   284

}

   285

   286

#if 0

   287

static const char* const _airport_heading_strings[] = {

   288

	"TO_ALL",

   289

	"HANGAR",

   290

	"TERM1",

   291

	"TERM2",

   292

	"TERM3",

   293

	"TERM4",

   294

	"TERM5",

   295

	"TERM6",

   296

	"HELIPAD1",

   297

	"HELIPAD2",

   298

	"TAKEOFF",

   299

	"STARTTAKEOFF",

   300

	"ENDTAKEOFF",

   301

	"HELITAKEOFF",

   302

	"FLYING",

   303

	"LANDING",

   304

	"ENDLANDING",

   305

	"HELILANDING",

   306

	"HELIENDLANDING",

   307

	"DUMMY"	// extra heading for 255

   308

};

   309

   310

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

   311

{

   312

	AirportFTA *temp;

   313

	uint16 i;

   314

	byte heading;

   315

   316

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

   317

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

   318

		temp = &Airport->layout[i];

   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

		} else {

   324

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

   325

		}

   326

		while (temp->next_in_chain != NULL) {

   327

			temp = temp->next_in_chain;

   328

			if (full_report) {

   329

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

   330

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

   331

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

   332

			} else {

   333

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

   334

			}

   335

		}

   336

		printf("\n");

   337

	}

   338

}

   339

   340

   341

static byte AirportBlockToString(uint32 block)

   342

{

   343

	byte i = 0;

   344

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

   345

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

   346

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

   347

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

   348

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

   349

	return i;

   350

}

   351

#endif

   352

   353

const AirportFTAClass* GetAirport(const byte airport_type)

   354

{

   355

	AirportFTAClass *Airport = NULL;

   356

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

   357

	// needs constant change if more airports are added

   358

	switch (airport_type) {

   359

		case AT_SMALL: Airport = CountryAirport; break;

   360

		case AT_LARGE: Airport = CityAirport; break;

   361

		case AT_METROPOLITAN: Airport = MetropolitanAirport; break;

   362

		case AT_HELIPORT: Airport = Heliport; break;

   363

		case AT_OILRIG: Airport = Oilrig; break;

   364

		case AT_INTERNATIONAL: Airport = InternationalAirport; break;

   365

		default:

   366

			#ifdef DEBUG__

   367

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

   368

			#endif

   369

			assert(airport_type <= AT_INTERNATIONAL);

   370

	}

   371

	return Airport;

   372

}

   373

   374

uint32 GetValidAirports(void)

   375

{

   376

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

   377

   378

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

   379

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

   380

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

   381

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

   382

	return bytemask;

   383

}