1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "map.h"

     4

#include "airport.h"

     5

     6

AirportFTAClass *CountryAirport;

     7

AirportFTAClass *CityAirport;

     8

AirportFTAClass *Heliport, *Oilrig;

     9

AirportFTAClass *MetropolitanAirport;

    10

AirportFTAClass *InternationalAirport;

    11

    12

static void AirportFTAClass_Constructor(AirportFTAClass *Airport,

    14

																				const byte entry_point,  const byte acc_planes,

    15

																				const AirportFTAbuildup *FA,

    16

																				const TileIndexDiffC *depots, const byte nof_depots);

    17

static void AirportFTAClass_Destructor(AirportFTAClass *Airport);

    18

    19

static uint16 AirportGetNofElements(const AirportFTAbuildup *FA);

    20

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

    21

static byte AirportTestFTA(const AirportFTAClass *Airport);

    22

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

    23

static byte AirportBlockToString(uint32 block);*/

    24

    25

void InitializeAirports()

    26

{

    27

	// country airport

    40

    41

	// city airport

    54

    55

	// metropolitan airport

    68

    69

	// international airport

    70

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

    82

    83

	// heliport, oilrig

    84

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

    97

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

    98

}

    99

   100

void UnInitializeAirports()

   101

{

   102

	AirportFTAClass_Destructor(CountryAirport);

   103

	AirportFTAClass_Destructor(CityAirport);

   104

	AirportFTAClass_Destructor(Heliport);

   105

	AirportFTAClass_Destructor(MetropolitanAirport);

   106

	AirportFTAClass_Destructor(InternationalAirport);

   107

}

   108

   109

static void AirportFTAClass_Constructor(AirportFTAClass *Airport,

   111

																				const byte entry_point, const byte acc_planes,

   112

																				const AirportFTAbuildup *FA,

   113

																				const TileIndexDiffC *depots, const byte nof_depots)

   114

{

   150

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

   151

	// same goes for helipads

   152

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

   153

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

   154

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

   155

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

   156

	// will get the less # of terminals

   157

   158

	assert(nofterminals <= MAX_TERMINALS);

   159

	assert(nofhelipads <= MAX_HELIPADS);

   160

   161

	Airport->nofelements = AirportGetNofElements(FA);

   162

	// check

   163

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

   164

	assert(entry_point < Airport->nofelements);

   165

   166

	Airport->acc_planes = acc_planes;

   167

	Airport->entry_point = entry_point;

   168

	Airport->airport_depots = depots;

   169

	Airport->nof_depots = nof_depots;

   170

   171

   172

	// build the state machine

   173

	AirportBuildAutomata(Airport, FA);

   176

   177

   178

	{

   179

		byte _retval = AirportTestFTA(Airport);

   180

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

   181

		assert(_retval == MAX_ELEMENTS);

   182

	}

   183

	// print out full information

   184

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

   185

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

   186

	//AirportPrintOut(Airport, false);

   187

}

   188

   189

static void AirportFTAClass_Destructor(AirportFTAClass *Airport)

   190

{

   191

	int i;

   192

	AirportFTA *current, *next;

   193

   194

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

   195

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

   196

		while (current != NULL) {

   197

			next = current->next_in_chain;

   198

			free(current);

   199

			current = next;

   200

		};

   201

	}

   202

	free(Airport->layout);

   203

	free(Airport);

   204

}

   205

   206

static uint16 AirportGetNofElements(const AirportFTAbuildup *FA)

   207

{

   208

	int i;

   209

	uint16 nofelements = 0;

   210

	int temp = FA[0].position;

   211

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

   212

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

   213

			nofelements++;

   214

			temp = FA[i].position;

   215

		}

   216

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

   217

	}

   218

	return nofelements;

   219

}

   220

   221

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

   222

{

   223

	AirportFTA *FAutomata;

   224

	AirportFTA *current;

   225

	uint16 internalcounter, i;

   226

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

   227

	Airport->layout = FAutomata;

   228

	internalcounter = 0;

   229

   230

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

   231

		current = &Airport->layout[i];

   232

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

   233

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

   234

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

   235

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

   236

   237

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

   238

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

   239

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

   240

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

   241

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

   242

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

   243

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

   244

			// create link

   245

			current->next_in_chain = newNode;

   246

			current = current->next_in_chain;

   247

			internalcounter++;

   248

		} // while

   249

		current->next_in_chain = NULL;

   250

		internalcounter++;

   251

	}

   252

}

   253

   254

static byte AirportTestFTA(const AirportFTAClass *Airport)

   255

{

   256

	byte position, i, next_element;

   257

	AirportFTA *temp;

   258

	next_element = 0;

   259

   260

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

   261

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

   262

		if (position != next_element) {return i;}

   263

		temp = &Airport->layout[i];

   264

   265

		do {

   266

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

   267

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

   268

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

   269

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

   270

			temp = temp->next_in_chain;

   271

		} while (temp != NULL);

   272

		next_element++;

   273

	}

   274

	return MAX_ELEMENTS;

   275

}

   276

   277

static const char* const _airport_heading_strings[MAX_HEADINGS+2] = {

   278

	"TO_ALL",

   279

	"HANGAR",

   280

	"TERM1",

   281

	"TERM2",

   282

	"TERM3",

   283

	"TERM4",

   284

	"TERM5",

   285

	"TERM6",

   286

	"HELIPAD1",

   287

	"HELIPAD2",

   288

	"TAKEOFF",

   289

	"STARTTAKEOFF",

   290

	"ENDTAKEOFF",

   291

	"HELITAKEOFF",

   292

	"FLYING",

   293

	"LANDING",

   294

	"ENDLANDING",

   295

	"HELILANDING",

   296

	"HELIENDLANDING",

   297

	"DUMMY"	// extra heading for 255

   298

};

   299

   300

/*

   301

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

   302

{

   303

	AirportFTA *temp;

   304

	uint16 i;

   305

	byte heading;

   306

   307

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

   308

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

   309

		temp = &Airport->layout[i];

   310

		if (full_report) {

   311

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

   312

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

   313

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

   314

		}

   315

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

   316

		while (temp->next_in_chain != NULL) {

   317

			temp = temp->next_in_chain;

   318

			if (full_report) {

   319

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

   320

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

   321

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

   322

			}

   323

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

   324

		}

   325

		printf("\n");

   326

	}

   327

}

   328

   329

   330

static byte AirportBlockToString(uint32 block)

   331

{

   332

	byte i = 0;

   333

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

   334

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

   335

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

   336

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

   337

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

   338

	return i;

   339

}*/

   340

   341

const AirportFTAClass* GetAirport(const byte airport_type)

   342

{

   343

	AirportFTAClass *Airport = NULL;

   344

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

   345

	// needs constant change if more airports are added

   346

	switch (airport_type) {

   347

		case AT_SMALL: Airport = CountryAirport; break;

   348

		case AT_LARGE: Airport = CityAirport; break;

   349

		case AT_METROPOLITAN: Airport = MetropolitanAirport; break;

   350

		case AT_HELIPORT: Airport = Heliport; break;

   351

		case AT_OILRIG: Airport = Oilrig; break;

   352

		case AT_INTERNATIONAL: Airport = InternationalAirport; break;

   353

		default:

   354

			#ifdef DEBUG__

   355

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

   356

			#endif

   357

			assert(airport_type <= AT_INTERNATIONAL);

   358

	}

   359

	return Airport;

   360

}