#define _GROUNDNETWORK_HXX_
#include <simgear/compiler.h>
-
+#include <simgear/route/waypoint.hxx>
#include STL_STRING
#include <vector>
SG_USING_STD(string);
SG_USING_STD(vector);
-
+#include "gnnode.hxx"
#include "parking.hxx"
#include "trafficcontrol.hxx"
-
-
class FGTaxiSegment; // forward reference
class FGAIFlightPlan; // forward reference
+class FGAirport; // forward reference
typedef vector<FGTaxiSegment*> FGTaxiSegmentVector;
typedef vector<FGTaxiSegment*>::iterator FGTaxiSegmentVectorIterator;
//typedef vector<FGTaxiSegment*> FGTaxiSegmentPointerVector;
//typedef vector<FGTaxiSegment*>::iterator FGTaxiSegmentPointerVectorIterator;
-/**************************************************************************************
- * class FGTaxiNode
- *************************************************************************************/
-class FGTaxiNode
-{
-private:
- double lat;
- double lon;
- int index;
- FGTaxiSegmentVector next; // a vector of pointers to all the segments leaving from this node
-
-public:
- FGTaxiNode();
- FGTaxiNode(double, double, int);
-
- void setIndex(int idx) { index = idx;};
- void setLatitude (double val) { lat = val;};
- void setLongitude(double val) { lon = val;};
- void setLatitude (const string& val) { lat = processPosition(val); };
- void setLongitude(const string& val) { lon = processPosition(val); };
- void addSegment(FGTaxiSegment *segment) { next.push_back(segment); };
-
- double getLatitude() { return lat;};
- double getLongitude(){ return lon;};
-
- int getIndex() { return index; };
- FGTaxiNode *getAddress() { return this;};
- FGTaxiSegmentVectorIterator getBeginRoute() { return next.begin(); };
- FGTaxiSegmentVectorIterator getEndRoute() { return next.end(); };
- bool operator<(const FGTaxiNode &other) const { return index < other.index; };
-};
-
-typedef vector<FGTaxiNode*> FGTaxiNodeVector;
-typedef vector<FGTaxiNode*>::iterator FGTaxiNodeVectorIterator;
-
/***************************************************************************************
* class FGTaxiSegment
**************************************************************************************/
int startNode;
int endNode;
double length;
+ double course;
+ double headingDiff;
+ bool isActive;
FGTaxiNode *start;
FGTaxiNode *end;
int index;
FGTaxiSegment *oppositeDirection;
+
+
public:
FGTaxiSegment();
//FGTaxiSegment(FGTaxiNode *, FGTaxiNode *, int);
FGTaxiSegment *getAddress() { return this;};
bool operator<(const FGTaxiSegment &other) const { return index < other.index; };
+ bool hasSmallerHeadingDiff (const FGTaxiSegment &other) const { return headingDiff < other.headingDiff; };
FGTaxiSegment *opposite() { return oppositeDirection; };
+ void setCourseDiff(double crse);
+
};
+
+
typedef vector<int> intVec;
typedef vector<int>::iterator intVecIterator;
+
+
/***************************************************************************************
* class FGTaxiRoute
**************************************************************************************/
intVec nodes;
intVec routes;
double distance;
+ int depth;
intVecIterator currNode;
intVecIterator currRoute;
public:
FGTaxiRoute() { distance = 0; currNode = nodes.begin(); currRoute = routes.begin();};
- FGTaxiRoute(intVec nds, intVec rts, double dist) {
+ FGTaxiRoute(intVec nds, intVec rts, double dist, int dpth) {
nodes = nds;
routes = rts;
distance = dist;
currNode = nodes.begin();
+ depth = dpth;
+ };
+
+ FGTaxiRoute& operator= (const FGTaxiRoute &other) {
+ nodes = other.nodes;
+ routes = other.routes;
+ distance = other.distance;
+ depth = other.depth;
+ currNode = nodes.begin();
+ currRoute = routes.begin();
+ return *this;
};
+
+ FGTaxiRoute(const FGTaxiRoute& copy) :
+ nodes(copy.nodes),
+ routes(copy.routes),
+ distance(copy.distance),
+ depth(copy.depth),
+ currNode(nodes.begin()),
+ currRoute(routes.begin())
+ {};
+
bool operator< (const FGTaxiRoute &other) const {return distance < other.distance; };
bool empty () { return nodes.begin() == nodes.end(); };
bool next(int *nde);
void first() { currNode = nodes.begin(); currRoute = routes.begin(); };
int size() { return nodes.size(); };
+ int getDepth() { return depth; };
};
typedef vector<FGTaxiRoute> TaxiRouteVector;
typedef vector<FGTaxiRoute>::iterator TaxiRouteVectorIterator;
-
-
-
/**************************************************************************************
* class FGGroundNetWork
*************************************************************************************/
{
private:
bool hasNetwork;
+ //int maxDepth;
+ int count;
FGTaxiNodeVector nodes;
FGTaxiSegmentVector segments;
//intVec route;
TaxiRouteVector routes;
TrafficVector activeTraffic;
TrafficVectorIterator currTraffic;
+ SGWayPoint destination;
bool foundRoute;
double totalDistance, maxDistance;
FGTowerController *towerController;
+ FGAirport *parent;
+
void printRoutingError(string);
FGTaxiNode *findNode(int idx);
FGTaxiSegment *findSegment(int idx);
FGTaxiRoute findShortestRoute(int start, int end);
- void trace(FGTaxiNode *, int, int, double dist);
+ //void trace(FGTaxiNode *, int, int, double dist);
+
+ void setParent(FGAirport *par) { parent = par; };
virtual void announcePosition(int id, FGAIFlightPlan *intendedRoute, int currentRoute,
- double lat, double lon, double hdg, double spd, double alt, double radius, int leg);
+ double lat, double lon, double hdg, double spd, double alt,
+ double radius, int leg, string callsign);
virtual void signOff(int id);
virtual void update(int id, double lat, double lon, double heading, double speed, double alt, double dt);
virtual bool hasInstruction(int id);
virtual FGATCInstruction getInstruction(int id);
+
+ bool checkForCircularWaits(int id);
};