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

#include "date.h"

    12

    13

static AirportFTAClass *CountryAirport;

    14

static AirportFTAClass *CityAirport;

    15

static AirportFTAClass *Oilrig;

    16

static AirportFTAClass *Heliport;

    17

static AirportFTAClass *MetropolitanAirport;

    18

static AirportFTAClass *InternationalAirport;

    19

static AirportFTAClass *CommuterAirport;

    20

static AirportFTAClass *HeliDepot;

    21

static AirportFTAClass *IntercontinentalAirport;

    22

static AirportFTAClass *HeliStation;

    23

    24

static void AirportFTAClass_Constructor(AirportFTAClass *Airport,

    25

	const byte *terminals, const byte *helipads,

    26

	const byte entry_point,  const byte acc_planes,

    27

	const AirportFTAbuildup *FA,

    28

	const TileIndexDiffC *depots, const byte nof_depots,

    29

	uint size_x, uint size_y

    30

);

    31

static void AirportFTAClass_Destructor(AirportFTAClass *Airport);

    32

    33

static uint16 AirportGetNofElements(const AirportFTAbuildup *FA);

    34

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

    35

static byte AirportTestFTA(const AirportFTAClass *Airport);

    36

#if 0

    37

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

    38

#endif

    39

    40

void InitializeAirports(void)

    41

{

    42

	// country airport

    43

	CountryAirport = malloc(sizeof(AirportFTAClass));

    44

    45

	AirportFTAClass_Constructor(

    46

		CountryAirport,

    47

		_airport_terminal_country,

    48

		NULL,

    49

		16,

    50

		ALL,

    51

		_airport_fta_country,

    52

		_airport_depots_country,

    53

		lengthof(_airport_depots_country),

    54

		4, 3

    55

	);

    56

    57

	// city airport

    58

	CityAirport = malloc(sizeof(AirportFTAClass));

    59

    60

	AirportFTAClass_Constructor(

    61

		CityAirport,

    62

		_airport_terminal_city,

    63

		NULL,

    64

		19,

    65

		ALL,

    66

		_airport_fta_city,

    67

		_airport_depots_city,

    68

		lengthof(_airport_depots_city),

    69

		6, 6

    70

	);

    71

    72

	// metropolitan airport

    73

	MetropolitanAirport = malloc(sizeof(AirportFTAClass));

    74

    75

	AirportFTAClass_Constructor(

    76

		MetropolitanAirport,

    77

		_airport_terminal_metropolitan,

    78

		NULL,

    79

		20,

    80

		ALL,

    81

		_airport_fta_metropolitan,

    82

		_airport_depots_metropolitan,

    83

		lengthof(_airport_depots_metropolitan),

    84

		6, 6

    85

	);

    86

    87

	// international airport

    88

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

    89

    90

	AirportFTAClass_Constructor(

    91

		InternationalAirport,

    92

		_airport_terminal_international,

    93

		_airport_helipad_international,

    94

		37,

    95

		ALL,

    96

		_airport_fta_international,

    97

		_airport_depots_international,

    98

		lengthof(_airport_depots_international),

    99

		7, 7

   100

	);

   101

   102

	// intercontintental airport

   103

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

   104

   105

	AirportFTAClass_Constructor(

   106

		IntercontinentalAirport,

   107

		_airport_terminal_intercontinental,

   108

		_airport_helipad_intercontinental,

   109

		43,

   110

		ALL,

   111

		_airport_fta_intercontinental,

   112

		_airport_depots_intercontinental,

   113

		lengthof(_airport_depots_intercontinental),

   114

		9,11

   115

	);

   116

   117

	// heliport, oilrig

   118

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

   119

   120

	AirportFTAClass_Constructor(

   121

		Heliport,

   122

		NULL,

   123

		_airport_helipad_heliport_oilrig,

   124

		7,

   125

		HELICOPTERS_ONLY,

   126

		_airport_fta_heliport_oilrig,

   127

		NULL,

   128

		0,

   129

		1, 1

   130

	);

   131

   132

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

   133

   134

	// commuter airport

   135

	CommuterAirport = malloc(sizeof(AirportFTAClass));

   136

   137

	AirportFTAClass_Constructor(

   138

		CommuterAirport,

   139

		_airport_terminal_commuter,

   140

		_airport_helipad_commuter,

   141

		22,

   142

		ALL,

   143

		_airport_fta_commuter,

   144

		_airport_depots_commuter,

   145

		lengthof(_airport_depots_commuter),

   146

		5,4

   147

	);

   148

   149

	// helidepot airport

   150

	HeliDepot = malloc(sizeof(AirportFTAClass));

   151

   152

	AirportFTAClass_Constructor(

   153

		HeliDepot,

   154

		NULL,

   155

		_airport_helipad_helidepot,

   156

		4,

   157

		HELICOPTERS_ONLY,

   158

		_airport_fta_helidepot,

   159

		_airport_depots_helidepot,

   160

		lengthof(_airport_depots_helidepot),

   161

		2,2

   162

	);

   163

   164

	// helistation airport

   165

	HeliStation = malloc(sizeof(AirportFTAClass));

   166

   167

	AirportFTAClass_Constructor(

   168

		HeliStation,

   169

		NULL,

   170

		_airport_helipad_helistation,

   171

		25,

   172

		HELICOPTERS_ONLY,

   173

		_airport_fta_helistation,

   174

		_airport_depots_helistation,

   175

		lengthof(_airport_depots_helistation),

   176

		4,2

   177

	);

   178

   179

}

   180

   181

void UnInitializeAirports(void)

   182

{

   183

	AirportFTAClass_Destructor(CountryAirport);

   184

	AirportFTAClass_Destructor(CityAirport);

   185

	AirportFTAClass_Destructor(Heliport);

   186

	AirportFTAClass_Destructor(MetropolitanAirport);

   187

	AirportFTAClass_Destructor(InternationalAirport);

   188

	AirportFTAClass_Destructor(CommuterAirport);

   189

	AirportFTAClass_Destructor(HeliDepot);

   190

	AirportFTAClass_Destructor(IntercontinentalAirport);

   191

	AirportFTAClass_Destructor(HeliStation);

   192

}

   193

   194

static void AirportFTAClass_Constructor(AirportFTAClass *Airport,

   195

																				const byte *terminals, const byte *helipads,

   196

																				const byte entry_point, const byte acc_planes,

   197

																				const AirportFTAbuildup *FA,

   198

																				const TileIndexDiffC *depots, const byte nof_depots,

   199

	uint size_x, uint size_y

   200

)

   201

{

   202

	byte nofterminals, nofhelipads;

   203

	byte nofterminalgroups = 0;

   204

	byte nofhelipadgroups = 0;

   205

	const byte *curr;

   206

	int i;

   207

	nofterminals = nofhelipads = 0;

   208

   209

	Airport->size_x = size_x;

   210

	Airport->size_y = size_y;

   211

   212

	//now we read the number of terminals we have

   213

	if (terminals != NULL) {

   214

		i = terminals[0];

   215

		nofterminalgroups = i;

   216

		curr = terminals;

   217

		while (i-- > 0) {

   218

			curr++;

   219

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

   220

			nofterminals += *curr;

   221

		}

   222

   223

	}

   224

	Airport->terminals = terminals;

   225

   226

	//read helipads

   227

	if (helipads != NULL) {

   228

		i = helipads[0];

   229

		nofhelipadgroups = i;

   230

		curr = helipads;

   231

		while (i-- > 0) {

   232

			curr++;

   233

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

   234

			nofhelipads += *curr;

   235

		}

   236

   237

	}

   238

	Airport->helipads = helipads;

   239

   240

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

   241

	// same goes for helipads

   242

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

   243

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

   244

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

   245

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

   246

	// will get the less # of terminals

   247

   248

	assert(nofterminals <= MAX_TERMINALS);

   249

	assert(nofhelipads <= MAX_HELIPADS);

   250

   251

	Airport->nofelements = AirportGetNofElements(FA);

   252

	// check

   253

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

   254

	assert(entry_point < Airport->nofelements);

   255

   256

	Airport->acc_planes = acc_planes;

   257

	Airport->entry_point = entry_point;

   258

	Airport->airport_depots = depots;

   259

	Airport->nof_depots = nof_depots;

   260

   261

   262

	// build the state machine

   263

	AirportBuildAutomata(Airport, FA);

   264

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

   265

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

   266

	);

   267

   268

   269

	{

   270

		byte ret = AirportTestFTA(Airport);

   271

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

   272

		assert(ret == MAX_ELEMENTS);

   273

	}

   274

	// print out full information

   275

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

   276

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

   277

#if 0

   278

	AirportPrintOut(Airport, false);

   279

#endif

   280

}

   281

   282

static void AirportFTAClass_Destructor(AirportFTAClass *Airport)

   283

{

   284

	int i;

   285

	AirportFTA *current, *next;

   286

   287

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

   288

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

   289

		while (current != NULL) {

   290

			next = current->next_in_chain;

   291

			free(current);

   292

			current = next;

   293

		};

   294

	}

   295

	free(Airport->layout);

   296

	free(Airport);

   297

}

   298

   299

static uint16 AirportGetNofElements(const AirportFTAbuildup *FA)

   300

{

   301

	int i;

   302

	uint16 nofelements = 0;

   303

	int temp = FA[0].position;

   304

   305

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

   306

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

   307

			nofelements++;

   308

			temp = FA[i].position;

   309

		}

   310

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

   311

	}

   312

	return nofelements;

   313

}

   314

   315

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

   316

{

   317

	AirportFTA *FAutomata;

   318

	AirportFTA *current;

   319

	uint16 internalcounter, i;

   320

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

   321

	Airport->layout = FAutomata;

   322

	internalcounter = 0;

   323

   324

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

   325

		current = &Airport->layout[i];

   326

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

   327

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

   328

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

   329

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

   330

   331

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

   332

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

   333

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

   334

   335

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

   336

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

   337

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

   338

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

   339

			// create link

   340

			current->next_in_chain = newNode;

   341

			current = current->next_in_chain;

   342

			internalcounter++;

   343

		} // while

   344

		current->next_in_chain = NULL;

   345

		internalcounter++;

   346

	}

   347

}

   348

   349

static byte AirportTestFTA(const AirportFTAClass *Airport)

   350

{

   351

	byte position, i, next_element;

   352

	AirportFTA *temp;

   353

	next_element = 0;

   354

   355

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

   356

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

   357

		if (position != next_element) return i;

   358

		temp = &Airport->layout[i];

   359

   360

		do {

   361

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

   362

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

   363

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

   364

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

   365

			temp = temp->next_in_chain;

   366

		} while (temp != NULL);

   367

		next_element++;

   368

	}

   369

	return MAX_ELEMENTS;

   370

}

   371

   372

#if 0

   373

static const char* const _airport_heading_strings[] = {

   374

	"TO_ALL",

   375

	"HANGAR",

   376

	"TERM1",

   377

	"TERM2",

   378

	"TERM3",

   379

	"TERM4",

   380

	"TERM5",

   381

	"TERM6",

   382

	"HELIPAD1",

   383

	"HELIPAD2",

   384

	"TAKEOFF",

   385

	"STARTTAKEOFF",

   386

	"ENDTAKEOFF",

   387

	"HELITAKEOFF",

   388

	"FLYING",

   389

	"LANDING",

   390

	"ENDLANDING",

   391

	"HELILANDING",

   392

	"HELIENDLANDING",

   393

	"TERM7",

   394

	"TERM8",

   395

	"HELIPAD3",

   396

	"HELIPAD4",

   397

	"DUMMY" // extra heading for 255

   398

};

   399

   400

   401

static uint AirportBlockToString(uint32 block)

   402

{

   403

	uint i = 0;

   404

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

   405

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

   406

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

   407

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

   408

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

   409

	return i;

   410

}

   411

   412

   413

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

   414

{

   415

	byte heading;

   416

	uint i;

   417

   418

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

   419

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

   420

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

   421

   422

		if (full_report) {

   423

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

   424

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

   425

				temp->position, temp->next_position,

   426

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

   427

			);

   428

		} else {

   429

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

   430

		}

   431

		while (temp->next_in_chain != NULL) {

   432

			temp = temp->next_in_chain;

   433

			if (full_report) {

   434

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

   435

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

   436

					temp->position, temp->next_position,

   437

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

   438

				);

   439

			} else {

   440

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

   441

			}

   442

		}

   443

		printf("\n");

   444

	}

   445

}

   446

#endif

   447

   448

const AirportFTAClass *GetAirport(const byte airport_type)

   449

{

   450

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

   451

	// needs constant change if more airports are added

   452

	switch (airport_type) {

   453

		default:               NOT_REACHED();

   454

		case AT_SMALL:         return CountryAirport;

   455

		case AT_LARGE:         return CityAirport;

   456

		case AT_METROPOLITAN:  return MetropolitanAirport;

   457

		case AT_HELIPORT:      return Heliport;

   458

		case AT_OILRIG:        return Oilrig;

   459

		case AT_INTERNATIONAL: return InternationalAirport;

   460

		case AT_COMMUTER:      return CommuterAirport;

   461

		case AT_HELIDEPOT:     return HeliDepot;

   462

		case AT_INTERCON:      return IntercontinentalAirport;

   463

		case AT_HELISTATION:   return HeliStation;

   464

	}

   465

}

   466

   467

const AirportMovingData *GetAirportMovingData(byte airport_type, byte position)

   468

{

   469

	assert(airport_type < lengthof(_airport_moving_datas));

   470

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

   471

	return &_airport_moving_datas[airport_type][position];

   472

}

   473

   474

uint32 GetValidAirports(void)

   475

{

   476

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

   477

   478

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

   479

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

   480

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

   481

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

   482

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

   483

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

   484

	return bytemask;

   485

}