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

static AirportFTAClass* CommuterAirport;

    19

static AirportFTAClass* HeliDepot;

    20

static AirportFTAClass* IntercontinentalAirport;

    21

static AirportFTAClass* HeliStation;

    22

    23

static void AirportFTAClass_Constructor(AirportFTAClass *Airport,

    24

	const byte *terminals, const byte *helipads,

    25

	const byte entry_point,  const byte acc_planes,

    26

	const AirportFTAbuildup *FA,

    27

	const TileIndexDiffC *depots, const byte nof_depots,

    28

	uint size_x, uint size_y

    29

);

    30

static void AirportFTAClass_Destructor(AirportFTAClass *Airport);

    31

    32

static uint16 AirportGetNofElements(const AirportFTAbuildup *FA);

    33

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

    34

static byte AirportTestFTA(const AirportFTAClass *Airport);

    35

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

    36

static byte AirportBlockToString(uint32 block);*/

    37

    38

void InitializeAirports(void)

    39

{

    40

	// country airport

    41

	CountryAirport = malloc(sizeof(AirportFTAClass));

    42

    43

	AirportFTAClass_Constructor(

    44

		CountryAirport,

    45

		_airport_terminal_country,

    46

		NULL,

    47

		16,

    48

		ALL,

    49

		_airport_fta_country,

    50

		_airport_depots_country,

    51

		lengthof(_airport_depots_country),

    52

		4, 3

    53

	);

    54

    55

	// city airport

    56

	CityAirport = malloc(sizeof(AirportFTAClass));

    57

    58

	AirportFTAClass_Constructor(

    59

		CityAirport,

    60

		_airport_terminal_city,

    61

		NULL,

    62

		19,

    63

		ALL,

    64

		_airport_fta_city,

    65

		_airport_depots_city,

    66

		lengthof(_airport_depots_city),

    67

		6, 6

    68

	);

    69

    70

	// metropolitan airport

    71

	MetropolitanAirport = malloc(sizeof(AirportFTAClass));

    72

    73

	AirportFTAClass_Constructor(

    74

		MetropolitanAirport,

    75

		_airport_terminal_metropolitan,

    76

		NULL,

    77

		20,

    78

		ALL,

    79

		_airport_fta_metropolitan,

    80

		_airport_depots_metropolitan,

    81

		lengthof(_airport_depots_metropolitan),

    82

		6, 6

    83

	);

    84

    85

	// international airport

    86

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

    87

    88

	AirportFTAClass_Constructor(

    89

		InternationalAirport,

    90

		_airport_terminal_international,

    91

		_airport_helipad_international,

    92

		37,

    93

		ALL,

    94

		_airport_fta_international,

    95

		_airport_depots_international,

    96

		lengthof(_airport_depots_international),

    97

		7, 7

    98

	);

    99

   100

	// intercontintental airport

   101

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

   102

   103

	AirportFTAClass_Constructor(

   104

		IntercontinentalAirport,

   105

		_airport_terminal_intercontinental,

   106

		_airport_helipad_intercontinental,

   107

		43,

   108

		ALL,

   109

		_airport_fta_intercontinental,

   110

		_airport_depots_intercontinental,

   111

		lengthof(_airport_depots_intercontinental),

   112

		9,11

   113

	);

   114

   115

	// heliport, oilrig

   116

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

   117

   118

	AirportFTAClass_Constructor(

   119

		Heliport,

   120

		NULL,

   121

		_airport_helipad_heliport_oilrig,

   122

		7,

   123

		HELICOPTERS_ONLY,

   124

		_airport_fta_heliport_oilrig,

   125

		NULL,

   126

		0,

   127

		1, 1

   128

	);

   129

   130

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

   131

   132

	// commuter airport

   133

	CommuterAirport = malloc(sizeof(AirportFTAClass));

   134

   135

	AirportFTAClass_Constructor(

   136

		CommuterAirport,

   137

		_airport_terminal_commuter,

   138

		_airport_helipad_commuter,

   139

		22,

   140

		ALL,

   141

		_airport_fta_commuter,

   142

		_airport_depots_commuter,

   143

		lengthof(_airport_depots_commuter),

   144

		5,4

   145

	);

   146

   147

	// helidepot airport

   148

	HeliDepot = malloc(sizeof(AirportFTAClass));

   149

   150

	AirportFTAClass_Constructor(

   151

		HeliDepot,

   152

		NULL,

   153

		_airport_helipad_helidepot,

   154

		4,

   155

		HELICOPTERS_ONLY,

   156

		_airport_fta_helidepot,

   157

		_airport_depots_helidepot,

   158

		lengthof(_airport_depots_helidepot),

   159

		2,2

   160

	);

   161

   162

	// helistation airport

   163

	HeliStation = malloc(sizeof(AirportFTAClass));

   164

   165

	AirportFTAClass_Constructor(

   166

		HeliStation,

   167

		NULL,

   168

		_airport_helipad_helistation,

   169

		25,

   170

		HELICOPTERS_ONLY,

   171

		_airport_fta_helistation,

   172

		_airport_depots_helistation,

   173

		lengthof(_airport_depots_helistation),

   174

		4,2

   175

	);

   176

   177

}

   178

   179

void UnInitializeAirports(void)

   180

{

   181

	AirportFTAClass_Destructor(CountryAirport);

   182

	AirportFTAClass_Destructor(CityAirport);

   183

	AirportFTAClass_Destructor(Heliport);

   184

	AirportFTAClass_Destructor(MetropolitanAirport);

   185

	AirportFTAClass_Destructor(InternationalAirport);

   186

	AirportFTAClass_Destructor(CommuterAirport);

   187

	AirportFTAClass_Destructor(HeliDepot);

   188

	AirportFTAClass_Destructor(IntercontinentalAirport);

   189

	AirportFTAClass_Destructor(HeliStation);

   190

}

   191

   192

static void AirportFTAClass_Constructor(AirportFTAClass *Airport,

   193

																				const byte *terminals, const byte *helipads,

   194

																				const byte entry_point, const byte acc_planes,

   195

																				const AirportFTAbuildup *FA,

   196

																				const TileIndexDiffC *depots, const byte nof_depots,

   197

	uint size_x, uint size_y

   198

)

   199

{

   200

	byte nofterminals, nofhelipads;

   201

	byte nofterminalgroups = 0;

   202

	byte nofhelipadgroups = 0;

   203

	const byte * curr;

   204

	int i;

   205

	nofterminals = nofhelipads = 0;

   206

   207

	Airport->size_x = size_x;

   208

	Airport->size_y = size_y;

   209

   210

	//now we read the number of terminals we have

   211

	if (terminals != NULL) {

   212

		i = terminals[0];

   213

		nofterminalgroups = i;

   214

		curr = terminals;

   215

		while (i-- > 0) {

   216

			curr++;

   217

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

   218

			nofterminals += *curr;

   219

		}

   220

   221

	}

   222

	Airport->terminals = terminals;

   223

   224

	//read helipads

   225

	if (helipads != NULL) {

   226

		i = helipads[0];

   227

		nofhelipadgroups = i;

   228

		curr = helipads;

   229

		while (i-- > 0) {

   230

			curr++;

   231

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

   232

			nofhelipads += *curr;

   233

		}

   234

   235

	}

   236

	Airport->helipads = helipads;

   237

   238

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

   239

	// same goes for helipads

   240

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

   241

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

   242

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

   243

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

   244

	// will get the less # of terminals

   245

   246

	assert(nofterminals <= MAX_TERMINALS);

   247

	assert(nofhelipads <= MAX_HELIPADS);

   248

   249

	Airport->nofelements = AirportGetNofElements(FA);

   250

	// check

   251

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

   252

	assert(entry_point < Airport->nofelements);

   253

   254

	Airport->acc_planes = acc_planes;

   255

	Airport->entry_point = entry_point;

   256

	Airport->airport_depots = depots;

   257

	Airport->nof_depots = nof_depots;

   258

   259

   260

	// build the state machine

   261

	AirportBuildAutomata(Airport, FA);

   262

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

   263

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

   264

	);

   265

   266

   267

	{

   268

		byte ret = AirportTestFTA(Airport);

   269

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

   270

		assert(ret == MAX_ELEMENTS);

   271

	}

   272

	// print out full information

   273

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

   274

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

   275

	//AirportPrintOut(Airport, false);

   276

}

   277

   278

static void AirportFTAClass_Destructor(AirportFTAClass *Airport)

   279

{

   280

	int i;

   281

	AirportFTA *current, *next;

   282

   283

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

   284

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

   285

		while (current != NULL) {

   286

			next = current->next_in_chain;

   287

			free(current);

   288

			current = next;

   289

		};

   290

	}

   291

	free(Airport->layout);

   292

	free(Airport);

   293

}

   294

   295

static uint16 AirportGetNofElements(const AirportFTAbuildup *FA)

   296

{

   297

	int i;

   298

	uint16 nofelements = 0;

   299

	int temp = FA[0].position;

   300

   301

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

   302

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

   303

			nofelements++;

   304

			temp = FA[i].position;

   305

		}

   306

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

   307

	}

   308

	return nofelements;

   309

}

   310

   311

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

   312

{

   313

	AirportFTA *FAutomata;

   314

	AirportFTA *current;

   315

	uint16 internalcounter, i;

   316

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

   317

	Airport->layout = FAutomata;

   318

	internalcounter = 0;

   319

   320

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

   321

		current = &Airport->layout[i];

   322

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

   323

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

   324

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

   325

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

   326

   327

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

   328

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

   329

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

   330

   331

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

   332

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

   333

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

   334

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

   335

			// create link

   336

			current->next_in_chain = newNode;

   337

			current = current->next_in_chain;

   338

			internalcounter++;

   339

		} // while

   340

		current->next_in_chain = NULL;

   341

		internalcounter++;

   342

	}

   343

}

   344

   345

static byte AirportTestFTA(const AirportFTAClass *Airport)

   346

{

   347

	byte position, i, next_element;

   348

	AirportFTA *temp;

   349

	next_element = 0;

   350

   351

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

   352

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

   353

		if (position != next_element) return i;

   354

		temp = &Airport->layout[i];

   355

   356

		do {

   357

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

   358

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

   359

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

   360

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

   361

			temp = temp->next_in_chain;

   362

		} while (temp != NULL);

   363

		next_element++;

   364

	}

   365

	return MAX_ELEMENTS;

   366

}

   367

   368

#if 0

   369

static const char* const _airport_heading_strings[] = {

   370

	"TO_ALL",

   371

	"HANGAR",

   372

	"TERM1",

   373

	"TERM2",

   374

	"TERM3",

   375

	"TERM4",

   376

	"TERM5",

   377

	"TERM6",

   378

	"HELIPAD1",

   379

	"HELIPAD2",

   380

	"TAKEOFF",

   381

	"STARTTAKEOFF",

   382

	"ENDTAKEOFF",

   383

	"HELITAKEOFF",

   384

	"FLYING",

   385

	"LANDING",

   386

	"ENDLANDING",

   387

	"HELILANDING",

   388

	"HELIENDLANDING",

   389

	"TERM7",

   390

	"TERM8",

   391

	"HELIPAD3",

   392

	"HELIPAD4",

   393

	"DUMMY"	// extra heading for 255

   394

};

   395

   396

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

   397

{

   398

	AirportFTA *temp;

   399

	uint16 i;

   400

	byte heading;

   401

   402

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

   403

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

   404

		temp = &Airport->layout[i];

   405

		if (full_report) {

   406

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

   407

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

   408

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

   409

		} else {

   410

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

   411

		}

   412

		while (temp->next_in_chain != NULL) {

   413

			temp = temp->next_in_chain;

   414

			if (full_report) {

   415

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

   416

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

   417

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

   418

			} else {

   419

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

   420

			}

   421

		}

   422

		printf("\n");

   423

	}

   424

}

   425

   426

   427

static byte AirportBlockToString(uint32 block)

   428

{

   429

	byte i = 0;

   430

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

   431

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

   432

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

   433

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

   434

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

   435

	return i;

   436

}

   437

#endif

   438

   439

const AirportFTAClass* GetAirport(const byte airport_type)

   440

{

   441

	AirportFTAClass *Airport = NULL;

   442

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

   443

	// needs constant change if more airports are added

   444

	switch (airport_type) {

   445

		case AT_SMALL:         Airport = CountryAirport; break;

   446

		case AT_LARGE:         Airport = CityAirport; break;

   447

		case AT_METROPOLITAN:  Airport = MetropolitanAirport; break;

   448

		case AT_HELIPORT:      Airport = Heliport; break;

   449

		case AT_OILRIG:        Airport = Oilrig; break;

   450

		case AT_INTERNATIONAL: Airport = InternationalAirport; break;

   451

		case AT_COMMUTER:      Airport = CommuterAirport; break;

   452

		case AT_HELIDEPOT:     Airport = HeliDepot; break;

   453

		case AT_INTERCON:      Airport = IntercontinentalAirport; break;

   454

		case AT_HELISTATION:   Airport = HeliStation; break;

   455

		default:

   456

			#ifdef DEBUG__

   457

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

   458

			#endif

   459

			assert(airport_type <= AT_HELISTATION);

   460

	}

   461

	return Airport;

   462

}

   463

   464

const AirportMovingData *GetAirportMovingData(byte airport_type, byte position)

   465

{

   466

	assert(airport_type < lengthof(_airport_moving_datas));

   467

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

   468

	return &_airport_moving_datas[airport_type][position];

   469

}

   470

   471

uint32 GetValidAirports(void)

   472

{

   473

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

   474

   475

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

   476

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

   477

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

   478

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

   479

	if (_date >= 23011) SETBIT(bytemask, 5); // commuter airport 1983

   480

	if (_date >= 20455) SETBIT(bytemask, 6); // helidepot 1976

   481

	if (_date >= 29951) SETBIT(bytemask, 7); // intercontinental airport 2002

   482

	if (_date >= 21915) SETBIT(bytemask, 8); // helistation 1980

   483

	return bytemask;

   484

}