X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=src%2FATC%2Fground.hxx;h=b0cf1f3d86fbe0fc89eaf5b8af1d4548a54cd675;hb=4606f96e139204d5b2d76ee93c3b0c66885b5f5f;hp=93bcb83d073b0952186a613c277b39e5cbb56146;hpb=df3e54cc47e1a80f27b8e5655b434130cced026b;p=flightgear.git diff --git a/src/ATC/ground.hxx b/src/ATC/ground.hxx index 93bcb83d0..b0cf1f3d8 100644 --- a/src/ATC/ground.hxx +++ b/src/ATC/ground.hxx @@ -35,7 +35,10 @@ SG_USING_STD(ios); #include #include "ATC.hxx" +//#include "ATCmgr.hxx" #include "ATCProjection.hxx" +#include "AIEntity.hxx" +//#include "AILocalTraffic.hxx" // RunwayDetails - this is a temporary hack SG_USING_STD(map); SG_USING_STD(vector); @@ -43,12 +46,12 @@ SG_USING_STD(list); ////////////////////////////////////////////////////// // Types for the logical network data structure -typedef enum arc_type { +enum arc_type { RUNWAY, TAXIWAY }; -typedef enum node_type { +enum node_type { GATE, APRON, HOLD, @@ -70,7 +73,7 @@ enum GateType { OTHER // ie. anything goes!! }; -typedef enum network_element_type { +enum network_element_type { NODE, ARC }; @@ -95,10 +98,13 @@ typedef arc_array_type::iterator arc_array_iterator; typedef arc_array_type::const_iterator arc_array_const_iterator; struct node : public ground_network_element { + node(); + ~node(); + unsigned int nodeID; //each node in an airport needs a unique ID number - this is ZERO-BASED to match array position Point3D pos; Point3D orthoPos; - char* name; + string name; node_type type; arc_array_type arcs; double max_turn_radius; @@ -113,23 +119,23 @@ struct Gate : public node { int max_weight; //units?? //airline_code airline; //For the future - we don't have any airline codes ATM int id; // The gate number in the logical scheme of things - string sid; // The real-world gate letter/number + string name; // The real-world gate letter/number //node* pNode; bool used; double heading; // The direction the parked-up plane should point in degrees }; -typedef vector < Gate > gate_vec_type; +typedef vector < Gate* > gate_vec_type; typedef gate_vec_type::iterator gate_vec_iterator; typedef gate_vec_type::const_iterator gate_vec_const_iterator; // A map of gate vs. the logical (internal FGFS) gate ID -typedef map < int, Gate > gate_map_type; +typedef map < int, Gate* > gate_map_type; typedef gate_map_type::iterator gate_map_iterator; typedef gate_map_type::const_iterator gate_map_const_iterator; // Runways - all the runway stuff is likely to change in the future -typedef struct Rwy { +struct Rwy { int id; //note this is a very simplified scheme for now - R & L are not differentiated //It should work for simple one rwy airports node_array_type exits; //Array of available exits from runway @@ -137,6 +143,7 @@ typedef struct Rwy { // Eventually we will also want some encoding of real-life preferred runways // This will get us up and running for single runway airports though. }; + typedef vector < Rwy > runway_array_type; typedef runway_array_type::iterator runway_array_iterator; typedef runway_array_type::const_iterator runway_array_const_iterator; @@ -154,29 +161,61 @@ typedef ground_network_path_type::const_iterator ground_network_path_const_itera ////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////// +// +// Stuff for the shortest-path algorithms +struct a_path { + a_path(); + + ground_network_path_type path; + int cost; +}; + +// Paths mapped by nodeID reached so-far +typedef map < unsigned int, a_path* > shortest_path_map_type; +typedef shortest_path_map_type::iterator shortest_path_map_iterator; + +// Nodes mapped by their ID +//typedef map < unsigned int, node* > node_map_type; +//typedef node_map_type::iterator node_map_iterator; +//////////////////////////////////////////////// + // Planes active within the ground network. -// somewhere in the ATC/AI system we are going to have defined something like -// typedef struct plane_rec -// list plane_rec_list_type -/* + // A more specialist plane rec to include ground information -typedef struct ground_rec { - plane_rec plane; - point current_pos; - node destination; - node last_clearance; +struct GroundRec { + FGAIEntity* planePtr; // This might move to the planeRec eventually + + PlaneRec plane; + Point3D current_pos; + node* destination; + node* last_clearance; + bool taxiRequestOutstanding; // Plane has requested taxi and we haven't responded yet + double clearanceCounter; // Hack for communication timing - counter since clearance requested in seconds + bool cleared; // set true when the plane has been cleared to somewhere bool incoming; //true for arrivals, false for departures // status? // Almost certainly need to add more here }; -typedef list ground_rec_list; +typedef list < GroundRec* > ground_rec_list; typedef ground_rec_list::iterator ground_rec_list_itr; typedef ground_rec_list::const_iterator ground_rec_list_const_itr; -*/ + ////////////////////////////////////////////////////////////////////////////////////////// +// Hack +// perhaps we could use an FGRunway instead of this +struct GRunwayDetails { + Point3D threshold_pos; + Point3D end1ortho; // ortho projection end1 (the threshold ATM) + Point3D end2ortho; // ortho projection end2 (the take off end in the current hardwired scheme) + double hdg; // true runway heading + double length; // In *METERS* + string rwyID; +}; + /////////////////////////////////////////////////////////////////////////////// // // FGGround @@ -186,23 +225,21 @@ class FGGround : public FGATC { public: FGGround(); + FGGround(string id); ~FGGround(); void Init(); - void Update(); + void Update(double dt); inline string get_trans_ident() { return trans_ident; } - inline atc_type GetType() { return GROUND; } inline void SetDisplay() {display = true;} inline void SetNoDisplay() {display = false;} - // Its possible that NewArrival and NewDeparture should simply be rolled into Request. - // Contact ground control on arrival, assumed to request any gate //void NewArrival(plane_rec plane); // Contact ground control on departure, assumed to request currently active runway. - //void NewDeparture(plane_rec plane); + void RequestDeparture(PlaneRec plane, FGAIEntity* requestee); // Contact ground control when the calling routine doesn't know if arrival // or departure is appropriate. @@ -217,23 +254,31 @@ public: // Return a suitable gate (maybe this should be a list of suitable gates so the plane or controller can choose the closest one) void ReturnGate(Gate &gate, GateType type); - //The following two functions have been made public for now but may go private with a higher level accessor at some point - // Return the internal ID of a random, suitable, unused gate - // For now we are simply implementing as any random unused gate - int GetRandomGateID(); - // Return a pointer to a node based on the gate ID - Gate* GetGateNode(int gateID); + // Return a pointer to an unused gate + Gate* GetGateNode(); + + // Return a pointer to a hold short node + node* GetHoldShortNode(string rwyID); // Runway stuff - this might change in the future. // Get a list of exits from a given runway // It is up to the calling function to check for non-zero size of returned array before use - node_array_type GetExits(int rwyID); + node_array_type GetExits(string rwyID); // Get a path from one node to another - ground_network_path_type GetPath(node* A, node* B); + ground_network_path_type GetPath(node* A, node* B); + + // Get a path from a node to a runway threshold + ground_network_path_type GetPath(node* A, string rwyID); + + // Get a path from a node to a runway hold short point + // Bit of a hack this at the moment! + ground_network_path_type GetPathToHoldShort(node* A, string rwyID); private: - + FGATCMgr* ATCmgr; + // This is purely for synactic convienience to avoid writing globals->get_ATC_mgr()-> all through the code! + // Need a data structure to hold details of the various active planes // Need a data structure to hold details of the logical network // including which gates are filled - or possibly another data structure @@ -249,10 +294,6 @@ private: // A map of all the gates indexed against internal (FGFS) ID gate_map_type gates; gate_map_iterator gatesItr; - - // Runway stuff - this might change in the future. - //runway_array_type runways; // STL way - Rwy runways[36]; // quick hack! FGATCAlignedProjection ortho; @@ -262,15 +303,16 @@ private: // Find the shortest route through the logical network between two points. //FindShortestRoute(point a, point b); - // Project a point in WGS84 lat/lon onto the local gnomonic. - //ConvertWGS84ToXY(sgVec3 wgs84, point xy); - // Assign a gate or parking location to a new arrival //AssignGate(ground_rec &g); // Generate the next clearance for an airplane //NextClearance(ground_rec &g); + // environment - need to make sure we're getting the surface winds and not winds aloft. + SGPropertyNode* wind_from_hdg; //degrees + SGPropertyNode* wind_speed_knots; //knots + bool display; // Flag to indicate whether we should be outputting to the ATC display. bool displaying; // Flag to indicate whether we are outputting to the ATC display. // for failure modeling @@ -278,12 +320,49 @@ private: bool ground_failed; // ground failed? bool networkLoadOK; // Indicates whether LoadNetwork returned true or false at last attempt + // Tower control + bool untowered; // True if this is an untowered airport (we still need the ground class for shortest path implementation etc + //FGATC* tower; // Pointer to the tower control + + // Logical runway details - this might change in the future. + //runway_array_type runways; // STL way + Rwy runways[37]; // quick hack! + + // Physical runway details + double aptElev; // Airport elevation + string activeRwy; // Active runway number - For now we'll disregard multiple / alternate runway operation. + RunwayDetails rwy; // Assumed to be the active one for now.// Figure out which runways are active. + + // For now we'll just be simple and do one active runway - eventually this will get much more complex + // Copied from FGTower - TODO - it would be better to implement this just once, and have ground call tower + // for runway operation details, but at the moment we can't guarantee that tower control at a given airport + // will be initialised before ground so we can't do that. + void DoRwyDetails(); + // Load the logical ground network for this airport from file. // Return true if successfull. bool LoadNetwork(); // Parse a runway exit string and push the supplied node pointer onto the runway exit list void ParseRwyExits(node* np, char* es); + + // Return a random gate ID of an unused gate. + // Two error values may be returned and must be checked for by the calling function: + // -2 signifies that no gates exist at this airport. + // -1 signifies that all gates are currently full. + // TODO - modify to return a suitable gate based on aircraft size/weight. + int GetRandomGateID(); + + // Return a pointer to the node at a runway threshold + // Returns NULL if unsuccessful. + node* GetThresholdNode(string rwyID); + + // A shortest path algorithm from memory (I can't find the bl&*dy book again!) + ground_network_path_type GetShortestPath(node* A, node* B); + + // Planes + ground_rec_list ground_traffic; + ground_rec_list_itr ground_traffic_itr; }; #endif // _FG_GROUND_HXX