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

#if 0

    36

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

    37

#endif

    38

    39

void InitializeAirports(void)

    40

{

    41

	// country airport

    42

	CountryAirport = malloc(sizeof(AirportFTAClass));

    43

    44

	AirportFTAClass_Constructor(

    45

		CountryAirport,

    46

		_airport_terminal_country,

    47

		NULL,

    48

		16,

    49

		ALL,

    50

		_airport_fta_country,

    51

		_airport_depots_country,

    52

		lengthof(_airport_depots_country),

    53

		4, 3

    54

	);

    55

    56

	// city airport

    57

	CityAirport = malloc(sizeof(AirportFTAClass));

    58

    59

	AirportFTAClass_Constructor(

    60

		CityAirport,

    61

		_airport_terminal_city,

    62

		NULL,

    63

		19,

    64

		ALL,

    65

		_airport_fta_city,

    66

		_airport_depots_city,

    67

		lengthof(_airport_depots_city),

    68

		6, 6

    69

	);

    70

    71

	// metropolitan airport

    72

	MetropolitanAirport = malloc(sizeof(AirportFTAClass));

    73

    74

	AirportFTAClass_Constructor(

    75

		MetropolitanAirport,

    76

		_airport_terminal_metropolitan,

    77

		NULL,

    78

		20,

    79

		ALL,

    80

		_airport_fta_metropolitan,

    81

		_airport_depots_metropolitan,

    82

		lengthof(_airport_depots_metropolitan),

    83

		6, 6

    84

	);

    85

    86

	// international airport

    87

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

    88

    89

	AirportFTAClass_Constructor(

    90

		InternationalAirport,

    91

		_airport_terminal_international,

    92

		_airport_helipad_international,

    93

		37,

    94

		ALL,

    95

		_airport_fta_international,

    96

		_airport_depots_international,

    97

		lengthof(_airport_depots_international),

    98

		7, 7

    99

	);

   100

   101

	// intercontintental airport

   102

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

   103

   104

	AirportFTAClass_Constructor(

   105

		IntercontinentalAirport,

   106

		_airport_terminal_intercontinental,

   107

		_airport_helipad_intercontinental,

   108

		43,

   109

		ALL,

   110

		_airport_fta_intercontinental,

   111

		_airport_depots_intercontinental,

   112

		lengthof(_airport_depots_intercontinental),

   113

		9,11

   114

	);

   115

   116

	// heliport, oilrig

   117

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

   118

   119

	AirportFTAClass_Constructor(

   120

		Heliport,

   121

		NULL,

   122

		_airport_helipad_heliport_oilrig,

   123

		7,

   124

		HELICOPTERS_ONLY,

   125

		_airport_fta_heliport_oilrig,

   126

		NULL,

   127

		0,

   128

		1, 1

   129

	);

   130

   131

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

   132

   133

	// commuter airport

   134

	CommuterAirport = malloc(sizeof(AirportFTAClass));

   135

   136

	AirportFTAClass_Constructor(

   137

		CommuterAirport,

   138

		_airport_terminal_commuter,

   139

		_airport_helipad_commuter,

   140

		22,

   141

		ALL,

   142

		_airport_fta_commuter,

   143

		_airport_depots_commuter,

   144

		lengthof(_airport_depots_commuter),

   145

		5,4

   146

	);

   147

   148

	// helidepot airport

   149

	HeliDepot = malloc(sizeof(AirportFTAClass));

   150

   151

	AirportFTAClass_Constructor(

   152

		HeliDepot,

   153

		NULL,

   154

		_airport_helipad_helidepot,

   155

		4,

   156

		HELICOPTERS_ONLY,

   157

		_airport_fta_helidepot,

   158

		_airport_depots_helidepot,

   159

		lengthof(_airport_depots_helidepot),

   160

		2,2

   161

	);

   162

   163

	// helistation airport

   164

	HeliStation = malloc(sizeof(AirportFTAClass));

   165

   166

	AirportFTAClass_Constructor(

   167

		HeliStation,

   168

		NULL,

   169

		_airport_helipad_helistation,

   170

		25,

   171

		HELICOPTERS_ONLY,

   172

		_airport_fta_helistation,

   173

		_airport_depots_helistation,

   174

		lengthof(_airport_depots_helistation),

   175

		4,2

   176

	);

   177

   178

}

   179

   180

void UnInitializeAirports(void)

   181

{

   182

	AirportFTAClass_Destructor(CountryAirport);

   183

	AirportFTAClass_Destructor(CityAirport);

   184

	AirportFTAClass_Destructor(Heliport);

   185

	AirportFTAClass_Destructor(MetropolitanAirport);

   186

	AirportFTAClass_Destructor(InternationalAirport);

   187

	AirportFTAClass_Destructor(CommuterAirport);

   188

	AirportFTAClass_Destructor(HeliDepot);

   189

	AirportFTAClass_Destructor(IntercontinentalAirport);

   190

	AirportFTAClass_Destructor(HeliStation);

   191

}

   192

   193

static void AirportFTAClass_Constructor(AirportFTAClass *Airport,

   194

																				const byte *terminals, const byte *helipads,

   195

																				const byte entry_point, const byte acc_planes,

   196

																				const AirportFTAbuildup *FA,

   197

																				const TileIndexDiffC *depots, const byte nof_depots,

   198

	uint size_x, uint size_y

   199

)

   200

{

   201

	byte nofterminals, nofhelipads;

   202

	byte nofterminalgroups = 0;

   203

	byte nofhelipadgroups = 0;

   204

	const byte * curr;

   205

	int i;

   206

	nofterminals = nofhelipads = 0;

   207

   208

	Airport->size_x = size_x;

   209

	Airport->size_y = size_y;

   210

   211

	//now we read the number of terminals we have

   212

	if (terminals != NULL) {

   213

		i = terminals[0];

   214

		nofterminalgroups = i;

   215

		curr = terminals;

   216

		while (i-- > 0) {

   217

			curr++;

   218

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

   219

			nofterminals += *curr;

   220

		}

   221

   222

	}

   223

	Airport->terminals = terminals;

   224

   225

	//read helipads

   226

	if (helipads != NULL) {

   227

		i = helipads[0];

   228

		nofhelipadgroups = i;

   229

		curr = helipads;

   230

		while (i-- > 0) {

   231

			curr++;

   232

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

   233

			nofhelipads += *curr;

   234

		}

   235

   236

	}

   237

	Airport->helipads = helipads;

   238

   239

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

   240

	// same goes for helipads

   241

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

   242

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

   243

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

   244

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

   245

	// will get the less # of terminals

   246

   247

	assert(nofterminals <= MAX_TERMINALS);

   248

	assert(nofhelipads <= MAX_HELIPADS);

   249

   250

	Airport->nofelements = AirportGetNofElements(FA);

   251

	// check

   252

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

   253

	assert(entry_point < Airport->nofelements);

   254

   255

	Airport->acc_planes = acc_planes;

   256

	Airport->entry_point = entry_point;

   257

	Airport->airport_depots = depots;

   258

	Airport->nof_depots = nof_depots;

   259

   260

   261

	// build the state machine

   262

	AirportBuildAutomata(Airport, FA);

   263

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

   264

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

   265

	);

   266

   267

   268

	{

   269

		byte ret = AirportTestFTA(Airport);

   270

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

   271

		assert(ret == MAX_ELEMENTS);

   272

	}

   273

	// print out full information

   274

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

   275

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

   276

#if 0

   277

	AirportPrintOut(Airport, false);

   278

#endif

   279

}

   280

   281

static void AirportFTAClass_Destructor(AirportFTAClass *Airport)

   282

{

   283

	int i;

   284

	AirportFTA *current, *next;

   285

   286

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

   287

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

   288

		while (current != NULL) {

   289

			next = current->next_in_chain;

   290

			free(current);

   291

			current = next;

   292

		};

   293

	}

   294

	free(Airport->layout);

   295

	free(Airport);

   296

}

   297

   298

static uint16 AirportGetNofElements(const AirportFTAbuildup *FA)

   299

{

   300

	int i;

   301

	uint16 nofelements = 0;

   302

	int temp = FA[0].position;

   303

   304

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

   305

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

   306

			nofelements++;

   307

			temp = FA[i].position;

   308

		}

   309

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

   310

	}

   311

	return nofelements;

   312

}

   313

   314

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

   315

{

   316

	AirportFTA *FAutomata;

   317

	AirportFTA *current;

   318

	uint16 internalcounter, i;

   319

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

   320

	Airport->layout = FAutomata;

   321

	internalcounter = 0;

   322

   323

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

   324

		current = &Airport->layout[i];

   325

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

   326

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

   327

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

   328

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

   329

   330

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

   331

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

   332

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

   333

   334

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

   335

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

   336

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

   337

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

   338

			// create link

   339

			current->next_in_chain = newNode;

   340

			current = current->next_in_chain;

   341

			internalcounter++;

   342

		} // while

   343

		current->next_in_chain = NULL;

   344

		internalcounter++;

   345

	}

   346

}

   347

   348

static byte AirportTestFTA(const AirportFTAClass *Airport)

   349

{

   350

	byte position, i, next_element;

   351

	AirportFTA *temp;

   352

	next_element = 0;

   353

   354

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

   355

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

   356

		if (position != next_element) return i;

   357

		temp = &Airport->layout[i];

   358

   359

		do {

   360

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

   361

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

   362

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

   363

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

   364

			temp = temp->next_in_chain;

   365

		} while (temp != NULL);

   366

		next_element++;

   367

	}

   368

	return MAX_ELEMENTS;

   369

}

   370

   371

#if 0

   372

static const char* const _airport_heading_strings[] = {

   373

	"TO_ALL",

   374

	"HANGAR",

   375

	"TERM1",

   376

	"TERM2",

   377

	"TERM3",

   378

	"TERM4",

   379

	"TERM5",

   380

	"TERM6",

   381

	"HELIPAD1",

   382

	"HELIPAD2",

   383

	"TAKEOFF",

   384

	"STARTTAKEOFF",

   385

	"ENDTAKEOFF",

   386

	"HELITAKEOFF",

   387

	"FLYING",

   388

	"LANDING",

   389

	"ENDLANDING",

   390

	"HELILANDING",

   391

	"HELIENDLANDING",

   392

	"TERM7",

   393

	"TERM8",

   394

	"HELIPAD3",

   395

	"HELIPAD4",

   396

	"DUMMY"	// extra heading for 255

   397

};

   398

   399

   400

static uint AirportBlockToString(uint32 block)

   401

{

   402

	uint i = 0;

   403

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

   404

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

   405

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

   406

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

   407

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

   408

	return i;

   409

}

   410

   411

   412

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

   413

{

   414

	byte heading;

   415

	uint i;

   416

   417

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

   418

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

   419

		const AirportFTA* temp = &Airport->layout[i];

   420

   421

		if (full_report) {

   422

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

   423

			printf("Pos:%2d NPos:%2d Heading:%15s Block:%2d\n",

   424

				temp->position, temp->next_position,

   425

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

   426

			);

   427

		} else {

   428

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

   429

		}

   430

		while (temp->next_in_chain != NULL) {

   431

			temp = temp->next_in_chain;

   432

			if (full_report) {

   433

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

   434

				printf("Pos:%2d NPos:%2d Heading:%15s Block:%2d\n",

   435

					temp->position, temp->next_position,

   436

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

   437

				);

   438

			} else {

   439

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

   440

			}

   441

		}

   442

		printf("\n");

   443

	}

   444

}

   445

#endif

   446

   447

const AirportFTAClass* GetAirport(const byte airport_type)

   448

{

   449

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

   450

	// needs constant change if more airports are added

   451

	switch (airport_type) {

   452

		default:               NOT_REACHED();

   453

		case AT_SMALL:         return CountryAirport;

   454

		case AT_LARGE:         return CityAirport;

   455

		case AT_METROPOLITAN:  return MetropolitanAirport;

   456

		case AT_HELIPORT:      return Heliport;

   457

		case AT_OILRIG:        return Oilrig;

   458

		case AT_INTERNATIONAL: return InternationalAirport;

   459

		case AT_COMMUTER:      return CommuterAirport;

   460

		case AT_HELIDEPOT:     return HeliDepot;

   461

		case AT_INTERCON:      return IntercontinentalAirport;

   462

		case AT_HELISTATION:   return HeliStation;

   463

	}

   464

}

   465

   466

const AirportMovingData *GetAirportMovingData(byte airport_type, byte position)

   467

{

   468

	assert(airport_type < lengthof(_airport_moving_datas));

   469

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

   470

	return &_airport_moving_datas[airport_type][position];

   471

}

   472

   473

uint32 GetValidAirports(void)

   474

{

   475

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

   476

   477

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

   478

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

   479

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

   480

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

   481

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

   482

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

   483

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

   484

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

   485

	return bytemask;

   486

}