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

#include "airport_movement.h"

    11

    12

static AirportFTAClass* CountryAirport;

    13

static AirportFTAClass* CityAirport;

    14

static AirportFTAClass* Oilrig;

    15

static AirportFTAClass* Heliport;

    16

static AirportFTAClass* MetropolitanAirport;

    17

static AirportFTAClass* InternationalAirport;

    18

    19

static void AirportFTAClass_Constructor(AirportFTAClass *Airport,

    20

																				const byte *terminals, const byte *helipads,

    21

																				const byte entry_point,  const byte acc_planes,

    22

																				const AirportFTAbuildup *FA,

    23

																				const TileIndexDiffC *depots, const byte nof_depots);

    24

static void AirportFTAClass_Destructor(AirportFTAClass *Airport);

    25

    26

static uint16 AirportGetNofElements(const AirportFTAbuildup *FA);

    27

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

    28

static byte AirportTestFTA(const AirportFTAClass *Airport);

    29

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

    30

static byte AirportBlockToString(uint32 block);*/

    31

    32

void InitializeAirports(void)

    33

{

    34

	// country airport

    35

	CountryAirport = malloc(sizeof(AirportFTAClass));

    36

    37

	AirportFTAClass_Constructor(

    38

		CountryAirport,

    39

		_airport_terminal_country,

    40

		NULL,

    41

		16,

    42

		ALL,

    43

		_airport_fta_country,

    44

		_airport_depots_country,

    45

		lengthof(_airport_depots_country)

    46

	);

    47

    48

	// city airport

    49

	CityAirport = malloc(sizeof(AirportFTAClass));

    50

    51

	AirportFTAClass_Constructor(

    52

		CityAirport,

    53

		_airport_terminal_city,

    54

		NULL,

    55

		19,

    56

		ALL,

    57

		_airport_fta_city,

    58

		_airport_depots_city,

    59

		lengthof(_airport_depots_city)

    60

	);

    61

    62

	// metropolitan airport

    63

	MetropolitanAirport = malloc(sizeof(AirportFTAClass));

    64

    65

	AirportFTAClass_Constructor(

    66

		MetropolitanAirport,

    67

		_airport_terminal_metropolitan,

    68

		NULL,

    69

		20,

    70

		ALL,

    71

		_airport_fta_metropolitan,

    72

		_airport_depots_metropolitan,

    73

		lengthof(_airport_depots_metropolitan)

    74

	);

    75

    76

	// international airport

    77

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

    78

    79

	AirportFTAClass_Constructor(

    80

		InternationalAirport,

    81

		_airport_terminal_international,

    82

		_airport_helipad_international,

    83

		37,

    84

		ALL,

    85

		_airport_fta_international,

    86

		_airport_depots_international,

    87

		lengthof(_airport_depots_international)

    88

	);

    89

    90

	// heliport, oilrig

    91

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

    92

    93

	AirportFTAClass_Constructor(

    94

		Heliport,

    95

		NULL,

    96

		_airport_helipad_heliport_oilrig,

    97

		7,

    98

		HELICOPTERS_ONLY,

    99

		_airport_fta_heliport_oilrig,

   100

		NULL,

   101

		0

   102

	);

   103

   104

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

   105

}

   106

   107

void UnInitializeAirports(void)

   108

{

   109

	AirportFTAClass_Destructor(CountryAirport);

   110

	AirportFTAClass_Destructor(CityAirport);

   111

	AirportFTAClass_Destructor(Heliport);

   112

	AirportFTAClass_Destructor(MetropolitanAirport);

   113

	AirportFTAClass_Destructor(InternationalAirport);

   114

}

   115

   116

static void AirportFTAClass_Constructor(AirportFTAClass *Airport,

   117

																				const byte *terminals, const byte *helipads,

   118

																				const byte entry_point, const byte acc_planes,

   119

																				const AirportFTAbuildup *FA,

   120

																				const TileIndexDiffC *depots, const byte nof_depots)

   121

{

   122

	byte nofterminals, nofhelipads;

   123

	byte nofterminalgroups = 0;

   124

	byte nofhelipadgroups = 0;

   125

	const byte * curr;

   126

	int i;

   127

	nofterminals = nofhelipads = 0;

   128

   129

	//now we read the number of terminals we have

   130

	if (terminals != NULL) {

   131

		i = terminals[0];

   132

		nofterminalgroups = i;

   133

		curr = terminals;

   134

		while (i-- > 0) {

   135

			curr++;

   136

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

   137

			nofterminals += *curr;

   138

		}

   139

   140

	}

   141

	Airport->terminals = terminals;

   142

   143

	//read helipads

   144

	if (helipads != NULL) {

   145

		i = helipads[0];

   146

		nofhelipadgroups = i;

   147

		curr = helipads;

   148

		while (i-- > 0) {

   149

			curr++;

   150

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

   151

			nofhelipads += *curr;

   152

		}

   153

   154

	}

   155

	Airport->helipads = helipads;

   156

   157

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

   158

	// same goes for helipads

   159

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

   160

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

   161

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

   162

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

   163

	// will get the less # of terminals

   164

   165

	assert(nofterminals <= MAX_TERMINALS);

   166

	assert(nofhelipads <= MAX_HELIPADS);

   167

   168

	Airport->nofelements = AirportGetNofElements(FA);

   169

	// check

   170

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

   171

	assert(entry_point < Airport->nofelements);

   172

   173

	Airport->acc_planes = acc_planes;

   174

	Airport->entry_point = entry_point;

   175

	Airport->airport_depots = depots;

   176

	Airport->nof_depots = nof_depots;

   177

   178

   179

	// build the state machine

   180

	AirportBuildAutomata(Airport, FA);

   181

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

   182

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

   183

	);

   184

   185

   186

	{

   187

		byte ret = AirportTestFTA(Airport);

   188

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

   189

		assert(ret == MAX_ELEMENTS);

   190

	}

   191

	// print out full information

   192

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

   193

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

   194

	//AirportPrintOut(Airport, false);

   195

}

   196

   197

static void AirportFTAClass_Destructor(AirportFTAClass *Airport)

   198

{

   199

	int i;

   200

	AirportFTA *current, *next;

   201

   202

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

   203

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

   204

		while (current != NULL) {

   205

			next = current->next_in_chain;

   206

			free(current);

   207

			current = next;

   208

		};

   209

	}

   210

	free(Airport->layout);

   211

	free(Airport);

   212

}

   213

   214

static uint16 AirportGetNofElements(const AirportFTAbuildup *FA)

   215

{

   216

	int i;

   217

	uint16 nofelements = 0;

   218

	int temp = FA[0].position;

   219

   220

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

   221

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

   222

			nofelements++;

   223

			temp = FA[i].position;

   224

		}

   225

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

   226

	}

   227

	return nofelements;

   228

}

   229

   230

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

   231

{

   232

	AirportFTA *FAutomata;

   233

	AirportFTA *current;

   234

	uint16 internalcounter, i;

   235

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

   236

	Airport->layout = FAutomata;

   237

	internalcounter = 0;

   238

   239

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

   240

		current = &Airport->layout[i];

   241

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

   242

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

   243

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

   244

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

   245

   246

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

   247

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

   248

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

   249

   250

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

   251

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

   252

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

   253

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

   254

			// create link

   255

			current->next_in_chain = newNode;

   256

			current = current->next_in_chain;

   257

			internalcounter++;

   258

		} // while

   259

		current->next_in_chain = NULL;

   260

		internalcounter++;

   261

	}

   262

}

   263

   264

static byte AirportTestFTA(const AirportFTAClass *Airport)

   265

{

   266

	byte position, i, next_element;

   267

	AirportFTA *temp;

   268

	next_element = 0;

   269

   270

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

   271

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

   272

		if (position != next_element) return i;

   273

		temp = &Airport->layout[i];

   274

   275

		do {

   276

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

   277

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

   278

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

   279

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

   280

			temp = temp->next_in_chain;

   281

		} while (temp != NULL);

   282

		next_element++;

   283

	}

   284

	return MAX_ELEMENTS;

   285

}

   286

   287

#if 0

   288

static const char* const _airport_heading_strings[] = {

   289

	"TO_ALL",

   290

	"HANGAR",

   291

	"TERM1",

   292

	"TERM2",

   293

	"TERM3",

   294

	"TERM4",

   295

	"TERM5",

   296

	"TERM6",

   297

	"HELIPAD1",

   298

	"HELIPAD2",

   299

	"TAKEOFF",

   300

	"STARTTAKEOFF",

   301

	"ENDTAKEOFF",

   302

	"HELITAKEOFF",

   303

	"FLYING",

   304

	"LANDING",

   305

	"ENDLANDING",

   306

	"HELILANDING",

   307

	"HELIENDLANDING",

   308

	"DUMMY"	// extra heading for 255

   309

};

   310

   311

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

   312

{

   313

	AirportFTA *temp;

   314

	uint16 i;

   315

	byte heading;

   316

   317

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

   318

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

   319

		temp = &Airport->layout[i];

   320

		if (full_report) {

   321

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

   322

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

   323

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

   324

		} else {

   325

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

   326

		}

   327

		while (temp->next_in_chain != NULL) {

   328

			temp = temp->next_in_chain;

   329

			if (full_report) {

   330

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

   331

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

   332

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

   333

			} else {

   334

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

   335

			}

   336

		}

   337

		printf("\n");

   338

	}

   339

}

   340

   341

   342

static byte AirportBlockToString(uint32 block)

   343

{

   344

	byte i = 0;

   345

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

   346

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

   347

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

   348

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

   349

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

   350

	return i;

   351

}

   352

#endif

   353

   354

const AirportFTAClass* GetAirport(const byte airport_type)

   355

{

   356

	AirportFTAClass *Airport = NULL;

   357

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

   358

	// needs constant change if more airports are added

   359

	switch (airport_type) {

   360

		case AT_SMALL: Airport = CountryAirport; break;

   361

		case AT_LARGE: Airport = CityAirport; break;

   362

		case AT_METROPOLITAN: Airport = MetropolitanAirport; break;

   363

		case AT_HELIPORT: Airport = Heliport; break;

   364

		case AT_OILRIG: Airport = Oilrig; break;

   365

		case AT_INTERNATIONAL: Airport = InternationalAirport; break;

   366

		default:

   367

			#ifdef DEBUG__

   368

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

   369

			#endif

   370

			assert(airport_type <= AT_INTERNATIONAL);

   371

	}

   372

	return Airport;

   373

}

   374

   375

const AirportMovingData *GetAirportMovingData(byte airport_type, byte position)

   376

{

   377

	assert(airport_type < lengthof(_airport_moving_datas));

   378

	assert(position < GetAirport(airport_type)->nofelements);

   379

	return &_airport_moving_datas[airport_type][position];

   380

}

   381

   382

uint32 GetValidAirports(void)

   383

{

   384

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

   385

   386

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

   387

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

   388

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

   389

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

   390

	return bytemask;

   391

}