#include "newgrf_sound.h"

#include "date.h"

static void CrashAirplane(Vehicle *v);

static void AircraftNextAirportPos_and_Order(Vehicle *v);

static void AircraftNextAirportPos_and_Order(Vehicle *v)

{

	const Station* st;

	if (v->current_order.type == OT_GOTO_STATION ||

			v->current_order.type == OT_GOTO_DEPOT)

		v->u.air.targetairport = v->current_order.dest;

	st = GetStation(v->u.air.targetairport);

}

static void AircraftLeaveHangar(Vehicle *v)

////////////////////////////////////////////////////////////////////////////////

///////////////////   AIRCRAFT MOVEMENT SCHEME  ////////////////////////////////

////////////////////////////////////////////////////////////////////////////////

{

	AircraftEntersTerminal(v);

}

{

	VehicleEnterDepot(v);

}

// In an Airport Hangar

{

	// if we just arrived, execute EnterHangar first

	if (v->u.air.previous_pos != v->u.air.pos) {

		return;

	}

		return;

	// if the block of the next position is busy, stay put

	// We are already at the target airport, we need to find a terminal

	if (v->current_order.dest == v->u.air.targetairport) {

		// FindFreeTerminal:

		// 1. Find a free terminal, 2. Occupy it, 3. Set the vehicle's state to that terminal

		if (v->subtype != 0) {

		} else {

		}

	} else { // Else prepare for launch.

		// airplane goto state takeoff, helicopter to helitakeoff

		v->u.air.state = (v->subtype != 0) ? TAKEOFF : HELITAKEOFF;

	}

	AircraftLeaveHangar(v);

}

// At one of the Airport's Terminals

{

	// if we just arrived, execute EnterTerminal first

	if (v->u.air.previous_pos != v->u.air.pos) {

		// on an airport with helipads, a helicopter will always land there

		// and get serviced at the same time - patch setting

		if (_patches.serviceathelipad) {

				// an exerpt of ServiceAircraft, without the invisibility stuff

				v->date_of_last_service = _date;

				v->breakdowns_since_last_service = 0;

	if (v->current_order.type == OT_NOTHING) return;

	// if the block of the next position is busy, stay put

		return;

	}

			v->current_order.flags = 0;

			v->u.air.state = HANGAR;

	}

}

{

	DEBUG(misc, 0) ("OK, you shouldn't be here, check your Airport Scheme!");

	assert(0);

}

	PlayAircraftSound(v); // play takeoffsound for airplanes

	v->u.air.state = STARTTAKEOFF;

}

{

	v->sprite_width = v->sprite_height = 24; // ??? no idea what this is

	v->u.air.state = ENDTAKEOFF;

}

{

	v->u.air.state = FLYING;

	// get the next position to go to, differs per airport

	AircraftNextAirportPos_and_Order(v);

}

{

	const Player* p = GetPlayer(v->owner);

	v->sprite_width = v->sprite_height = 24; // ??? no idea what this is

	}

}

{

	Station *st;

	byte landingtype;

	// all other airports --> all types of flying devices (ALL)

	// heliport/oilrig, etc --> no airplanes (HELICOPTERS_ONLY)

	// runway busy or not allowed to use this airstation, circle

			st->airport_tile != 0 &&

			(st->owner == OWNER_NONE || st->owner == v->owner)) {

		// {32,FLYING,NOTHING_block,37}, {32,LANDING,N,33}, {32,HELILANDING,N,41},

		// if it is an airplane, look for LANDING, for helicopter HELILANDING

		// it is possible to choose from multiple landing runways, so loop until a free one is found

		landingtype = (v->subtype != 0) ? LANDING : HELILANDING;

		while (current != NULL) {

			if (current->heading == landingtype) {

				// save speed before, since if AirportHasBlock is false, it resets them to 0

				// hack for speed thingie

				tcur_speed = v->cur_speed;

				tsubspeed = v->subspeed;

					v->u.air.state = landingtype; // LANDING / HELILANDING

					// it's a bit dirty, but I need to set position to next position, otherwise

					// if there are multiple runways, plane won't know which one it took (because

					// they all have heading LANDING). And also occupy that block!

					v->u.air.pos = current->next_position;

					return;

				}

				v->cur_speed = tcur_speed;

				v->subspeed = tsubspeed;

			}

		}

	}

	v->u.air.state = FLYING;

}

{

	const Player* p = GetPlayer(v->owner);

	AircraftLandAirplane(v);  // maybe crash airplane

	}

}

{

	AircraftLand(v); // helicopters don't crash

	v->u.air.state = HELIENDLANDING;

}

{

	// next block busy, don't do a thing, just wait

	// if going to terminal (OT_GOTO_STATION) choose one

	// 1. in case all terminals are busy AirportFindFreeTerminal() returns false or

	// 2. not going for terminal (but depot, no order),

	// --> get out of the way to the hangar.

	if (v->current_order.type == OT_GOTO_STATION) {

	}

	v->u.air.state = HANGAR;

}

{

	// next block busy, don't do a thing, just wait

	// if going to helipad (OT_GOTO_STATION) choose one. If airport doesn't have helipads, choose terminal

	// 1. in case all terminals/helipads are busy (AirportFindFreeHelipad() returns false) or

	// the reason behind this is that if an airport has a terminal, it also has a hangar. Airplanes

	// must go to a hangar.

	if (v->current_order.type == OT_GOTO_STATION) {

	}

}

static AircraftStateHandler * const _aircraft_state_handlers[] = {

	AircraftEventHandler_General,        // TO_ALL         =  0

	AircraftEventHandler_InHangar,       // HANGAR         =  1

	AircraftEventHandler_AtTerminal,     // HELIPAD4       = 22

};

{

	// we have left the previous block, and entered the new one. Free the previous block

		Station *st = GetStation(v->u.air.targetairport);

	}

}

{

	// if aircraft is not in position, wait until it is

	if (!AircraftController(v)) return;

}

// gets pos from vehicle and next orders

{

	AirportFTA *current;

	byte prev_pos;

	// error handling

	}

	// we have arrived in an important state (eg terminal, hangar, etc.)

	if (current->heading == v->u.air.state) {

		prev_pos = v->u.air.pos; // location could be changed in state, so save it before-hand

		if (v->u.air.state != FLYING) v->u.air.previous_pos = prev_pos;

		return true;

	}

	v->u.air.previous_pos = v->u.air.pos; // save previous location

	// there is only one choice to move to

			v->u.air.pos = current->next_position;

		} // move to next position

		return false;

	// matches our heading

	do {

		if (v->u.air.state == current->heading || current->heading == TO_ALL) {

				v->u.air.pos = current->next_position;

			} // move to next position

			return false;

		}

	} while (current != NULL);

	DEBUG(misc, 0) ("Cannot move further on Airport...! pos:%d state:%d", v->u.air.pos, v->u.air.state);

	assert(0);

	return false;

}

// returns true if the road ahead is busy, eg. you must wait before proceeding

{

	// same block, then of course we can move

		const Station* st = GetStation(v->u.air.targetairport);

		uint32 airport_flags = next->block;

}

// returns true on success. Eg, next block was free and we have occupied it

{

	AirportFTA* current;

	// if the next position is in another block, check it and wait until it is free

		uint32 airport_flags = next->block;

		Station* st = GetStation(v->u.air.targetairport);

		//search for all all elements in the list with the same state, and blocks != N

		// this means more blocks should be checked/set

		current = current_pos;

		while (current != NULL) {

			if (current->heading == current_pos->heading && current->block != 0) {

				airport_flags |= current->block;

				break;

			}

		};

		// if the block to be checked is in the next position, then exclude that from

	return false;

}

{

	uint num = 0;

	uint i;

	return num;

}

{

	AirportFTA *temp;

	Station *st;

	 * possible groups are checked (in this case group 1, since that is after group 0). If that

	 * fails, then attempt fails and plane waits

	 */

		st = GetStation(v->u.air.targetairport);

		while (temp != NULL) {

			if (temp->heading == 255) {

				if (!HASBITS(st->airport_flags, temp->block)) {

					//that means, sum up all terminals of

					//groups with lower number

					for (i = 1; i < target_group; i++)

					if (FreeTerminal(v, group_start, group_end)) return true;

				}

			} else {

				 * So we cannot move */

				return false;

			}

		}

	}

	// if there is only 1 terminalgroup, all terminals are checked (starting from 0 to max)

}

{

	uint num = 0;

	uint i;

	return num;

}

{

	// if an airport doesn't have helipads, use terminals

	// if there are more helicoptergroups, pick one, just as in AirportFindFreeTerminal()

		const Station* st = GetStation(v->u.air.targetairport);

		while (temp != NULL) {

			if (temp->heading == 255) {

					//that means, sum up all terminals of

					//groups with lower number

					for (i = 1; i < target_group; i++)

					if (FreeTerminal(v, group_start, group_end)) return true;

				}

			} else {

				 * So we cannot move */

				return false;

			}

		}

	} else {

		// only 1 helicoptergroup, check all helipads

		// The blocks for helipads start after the last terminal (MAX_TERMINALS)

	}

	return false; // it shouldn't get here anytime, but just to be sure

}

static AirportFTAClass *IntercontinentalAirport;

static AirportFTAClass *HeliStation;

	const byte *terminals, const byte *helipads,

	const byte entry_point,  const byte acc_planes,

	const TileIndexDiffC *depots, const byte nof_depots,

	uint size_x, uint size_y

);

#if 0

#endif

void InitializeAirports(void)

	AirportFTAClass_Destructor(HeliStation);

}

	uint size_x, uint size_y

)

{

	int i;

	nofterminals = nofhelipads = 0;

	//now we read the number of terminals we have

	if (terminals != NULL) {

		}

	}

	//read helipads

	if (helipads != NULL) {

		}

	}

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

	// same goes for helipads

	assert(nofterminals <= MAX_TERMINALS);

	assert(nofhelipads <= MAX_HELIPADS);

	// check

	// build the state machine

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

	);

	{

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

		assert(ret == MAX_ELEMENTS);

	}

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

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

#if 0

#endif

}

{

	int i;

	AirportFTA *current, *next;

		while (current != NULL) {

			free(current);

			current = next;

		};

	}

}

{

	int i;

	uint16 nofelements = 0;

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

			nofelements++;

		}

	}

	return nofelements;

}

{

	AirportFTA *FAutomata;

	AirportFTA *current;

	uint16 internalcounter, i;

	internalcounter = 0;

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

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

			// create link

			internalcounter++;

		} // while

		internalcounter++;

	}

}

{

	byte position, i, next_element;

	AirportFTA *temp;

	next_element = 0;

		if (position != next_element) return i;