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

	uint size_x, uint size_y

    25

);

    26

static void AirportFTAClass_Destructor(AirportFTAClass *Airport);

    27

    28

static uint16 AirportGetNofElements(const AirportFTAbuildup *FA);

    29

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

    30

static byte AirportTestFTA(const AirportFTAClass *Airport);

    31

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

    32

static byte AirportBlockToString(uint32 block);*/

    33

    34

void InitializeAirports(void)

    35

{

    36

	// country airport

    37

	CountryAirport = malloc(sizeof(AirportFTAClass));

    38

    39

	AirportFTAClass_Constructor(

    40

		CountryAirport,

    41

		_airport_terminal_country,

    42

		NULL,

    43

		16,

    44

		ALL,

    45

		_airport_fta_country,

    46

		_airport_depots_country,

    47

		lengthof(_airport_depots_country),

    48

		4, 3

    49

	);

    50

    51

	// city airport

    52

	CityAirport = malloc(sizeof(AirportFTAClass));

    53

    54

	AirportFTAClass_Constructor(

    55

		CityAirport,

    56

		_airport_terminal_city,

    57

		NULL,

    58

		19,

    59

		ALL,

    60

		_airport_fta_city,

    61

		_airport_depots_city,

    62

		lengthof(_airport_depots_city),

    63

		6, 6

    64

	);

    65

    66

	// metropolitan airport

    67

	MetropolitanAirport = malloc(sizeof(AirportFTAClass));

    68

    69

	AirportFTAClass_Constructor(

    70

		MetropolitanAirport,

    71

		_airport_terminal_metropolitan,

    72

		NULL,

    73

		20,

    74

		ALL,

    75

		_airport_fta_metropolitan,

    76

		_airport_depots_metropolitan,

    77

		lengthof(_airport_depots_metropolitan),

    78

		6, 6

    79

	);

    80

    81

	// international airport

    82

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

    83

    84

	AirportFTAClass_Constructor(

    85

		InternationalAirport,

    86

		_airport_terminal_international,

    87

		_airport_helipad_international,

    88

		37,

    89

		ALL,

    90

		_airport_fta_international,

    91

		_airport_depots_international,

    92

		lengthof(_airport_depots_international),

    93

		7, 7

    94

	);

    95

    96

	// heliport, oilrig

    97

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

    98

    99

	AirportFTAClass_Constructor(

   100

		Heliport,

   101

		NULL,

   102

		_airport_helipad_heliport_oilrig,

   103

		7,

   104

		HELICOPTERS_ONLY,

   105

		_airport_fta_heliport_oilrig,

   106

		NULL,

   107

		0,

   108

		1, 1

   109

	);

   110

   111

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

   112

}

   113

   114

void UnInitializeAirports(void)

   115

{

   116

	AirportFTAClass_Destructor(CountryAirport);

   117

	AirportFTAClass_Destructor(CityAirport);

   118

	AirportFTAClass_Destructor(Heliport);

   119

	AirportFTAClass_Destructor(MetropolitanAirport);

   120

	AirportFTAClass_Destructor(InternationalAirport);

   121

}

   122

   123

static void AirportFTAClass_Constructor(AirportFTAClass *Airport,

   124

																				const byte *terminals, const byte *helipads,

   125

																				const byte entry_point, const byte acc_planes,

   126

																				const AirportFTAbuildup *FA,

   127

																				const TileIndexDiffC *depots, const byte nof_depots,

   128

	uint size_x, uint size_y

   129

)

   130

{

   131

	byte nofterminals, nofhelipads;

   132

	byte nofterminalgroups = 0;

   133

	byte nofhelipadgroups = 0;

   134

	const byte * curr;

   135

	int i;

   136

	nofterminals = nofhelipads = 0;

   137

   138

	Airport->size_x = size_x;

   139

	Airport->size_y = size_y;

   140

   141

	//now we read the number of terminals we have

   142

	if (terminals != NULL) {

   143

		i = terminals[0];

   144

		nofterminalgroups = i;

   145

		curr = terminals;

   146

		while (i-- > 0) {

   147

			curr++;

   148

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

   149

			nofterminals += *curr;

   150

		}

   151

   152

	}

   153

	Airport->terminals = terminals;

   154

   155

	//read helipads

   156

	if (helipads != NULL) {

   157

		i = helipads[0];

   158

		nofhelipadgroups = i;

   159

		curr = helipads;

   160

		while (i-- > 0) {

   161

			curr++;

   162

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

   163

			nofhelipads += *curr;

   164

		}

   165

   166

	}

   167

	Airport->helipads = helipads;

   168

   169

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

   170

	// same goes for helipads

   171

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

   172

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

   173

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

   174

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

   175

	// will get the less # of terminals

   176

   177

	assert(nofterminals <= MAX_TERMINALS);

   178

	assert(nofhelipads <= MAX_HELIPADS);

   179

   180

	Airport->nofelements = AirportGetNofElements(FA);

   181

	// check

   182

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

   183

	assert(entry_point < Airport->nofelements);

   184

   185

	Airport->acc_planes = acc_planes;

   186

	Airport->entry_point = entry_point;

   187

	Airport->airport_depots = depots;

   188

	Airport->nof_depots = nof_depots;

   189

   190

   191

	// build the state machine

   192

	AirportBuildAutomata(Airport, FA);

   193

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

   194

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

   195

	);

   196

   197

   198

	{

   199

		byte ret = AirportTestFTA(Airport);

   200

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

   201

		assert(ret == MAX_ELEMENTS);

   202

	}

   203

	// print out full information

   204

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

   205

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

   206

	//AirportPrintOut(Airport, false);

   207

}

   208

   209

static void AirportFTAClass_Destructor(AirportFTAClass *Airport)

   210

{

   211

	int i;

   212

	AirportFTA *current, *next;

   213

   214

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

   215

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

   216

		while (current != NULL) {

   217

			next = current->next_in_chain;

   218

			free(current);

   219

			current = next;

   220

		};

   221

	}

   222

	free(Airport->layout);

   223

	free(Airport);

   224

}

   225

   226

static uint16 AirportGetNofElements(const AirportFTAbuildup *FA)

   227

{

   228

	int i;

   229

	uint16 nofelements = 0;

   230

	int temp = FA[0].position;

   231

   232

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

   233

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

   234

			nofelements++;

   235

			temp = FA[i].position;

   236

		}

   237

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

   238

	}

   239

	return nofelements;

   240

}

   241

   242

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

   243

{

   244

	AirportFTA *FAutomata;

   245

	AirportFTA *current;

   246

	uint16 internalcounter, i;

   247

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

   248

	Airport->layout = FAutomata;

   249

	internalcounter = 0;

   250

   251

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

   252

		current = &Airport->layout[i];

   253

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

   254

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

   255

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

   256

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

   257

   258

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

   259

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

   260

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

   261

   262

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

   263

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

   264

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

   265

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

   266

			// create link

   267

			current->next_in_chain = newNode;

   268

			current = current->next_in_chain;

   269

			internalcounter++;

   270

		} // while

   271

		current->next_in_chain = NULL;

   272

		internalcounter++;

   273

	}

   274

}

   275

   276

static byte AirportTestFTA(const AirportFTAClass *Airport)

   277

{

   278

	byte position, i, next_element;

   279

	AirportFTA *temp;

   280

	next_element = 0;

   281

   282

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

   283

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

   284

		if (position != next_element) return i;

   285

		temp = &Airport->layout[i];

   286

   287

		do {

   288

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

   289

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

   290

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

   291

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

   292

			temp = temp->next_in_chain;

   293

		} while (temp != NULL);

   294

		next_element++;

   295

	}

   296

	return MAX_ELEMENTS;

   297

}

   298

   299

#if 0

   300

static const char* const _airport_heading_strings[] = {

   301

	"TO_ALL",

   302

	"HANGAR",

   303

	"TERM1",

   304

	"TERM2",

   305

	"TERM3",

   306

	"TERM4",

   307

	"TERM5",

   308

	"TERM6",

   309

	"HELIPAD1",

   310

	"HELIPAD2",

   311

	"TAKEOFF",

   312

	"STARTTAKEOFF",

   313

	"ENDTAKEOFF",

   314

	"HELITAKEOFF",

   315

	"FLYING",

   316

	"LANDING",

   317

	"ENDLANDING",

   318

	"HELILANDING",

   319

	"HELIENDLANDING",

   320

	"DUMMY"	// extra heading for 255

   321

};

   322

   323

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

   324

{

   325

	AirportFTA *temp;

   326

	uint16 i;

   327

	byte heading;

   328

   329

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

   330

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

   331

		temp = &Airport->layout[i];

   332

		if (full_report) {

   333

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

   334

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

   335

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

   336

		} else {

   337

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

   338

		}

   339

		while (temp->next_in_chain != NULL) {

   340

			temp = temp->next_in_chain;

   341

			if (full_report) {

   342

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

   343

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

   344

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

   345

			} else {

   346

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

   347

			}

   348

		}

   349

		printf("\n");

   350

	}

   351

}

   352

   353

   354

static byte AirportBlockToString(uint32 block)

   355

{

   356

	byte i = 0;

   357

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

   358

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

   359

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

   360

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

   361

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

   362

	return i;

   363

}

   364

#endif

   365

   366

const AirportFTAClass* GetAirport(const byte airport_type)

   367

{

   368

	AirportFTAClass *Airport = NULL;

   369

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

   370

	// needs constant change if more airports are added

   371

	switch (airport_type) {

   372

		case AT_SMALL: Airport = CountryAirport; break;

   373

		case AT_LARGE: Airport = CityAirport; break;

   374

		case AT_METROPOLITAN: Airport = MetropolitanAirport; break;

   375

		case AT_HELIPORT: Airport = Heliport; break;

   376

		case AT_OILRIG: Airport = Oilrig; break;

   377

		case AT_INTERNATIONAL: Airport = InternationalAirport; break;

   378

		default:

   379

			#ifdef DEBUG__

   380

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

   381

			#endif

   382

			assert(airport_type <= AT_INTERNATIONAL);

   383

	}

   384

	return Airport;

   385

}

   386

   387

const AirportMovingData *GetAirportMovingData(byte airport_type, byte position)

   388

{

   389

	assert(airport_type < lengthof(_airport_moving_datas));

   390

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

   391

	return &_airport_moving_datas[airport_type][position];

   392

}

   393

   394

uint32 GetValidAirports(void)

   395

{

   396

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

   397

   398

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

   399

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

   400

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

   401

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

   402

	return bytemask;

   403

}